@oak-digital/types-4-strapi-2 0.3.6 → 0.5.0

package/.eslintrc.json

@@ -32,10 +32,6 @@
         "no-return-await": ["error"],
         "no-var": ["error"],
         "no-cond-assign": ["error", "always"],
-        "indent": [
-            "error",
-            4
-        ],
         "linebreak-style": [
             "error",
             "unix"

package/.prettierrc.json

@@ -1,6 +1,7 @@
 {
     "parser": "typescript",
     "semi": true,
+    "indent": 4,
     "singleQuote": true,
     "bracketSameLine": false,
     "trailingComma": "es5"

package/README.md

@@ -49,11 +49,12 @@ This can be done with the `--out` flag like in the following example.
 * Generate TypeScript interfaces for builtin types such as `Media` and `MediaFormat`
 * Select input and output directory
 * Prettier formatting and ability to use your own `.prettierrc`.
+* Generate types for plugins such as [url-alias](https://github.com/strapi-community/strapi-plugin-url-alias)
+* Population by generics
 
 ### Planned features
 
 * Support for localization
-* Support if you are using other plugins, such as `url-alias`, which should add extra fields for some interfaces.
 
 ## Flags
 
@@ -65,6 +66,45 @@ This can be done with the `--out` flag like in the following example.
 | --component-prefix <prefix> | A prefix for components                                                              | none        |
 | -D, --delete-old            | CAUTION: This option is equivalent to running `rm -rf` on the output directory first | `false`     |
 | --prettier <file>           | The prettier config file to use for formatting TypeScript interfaces                 | none        |
+| --plugins <plugins...>      | The plugins to use                                                                   | none        |
+
+## Using plugins
+
+It is possible to generate types for plugins, for example url-alias gives a new field on your content types, so that plugin will automatically add that field to your types.
+You can see a list of builtin plugins below.
+Some plugins might not be fully featured.
+
+It will be possible in the future to add your own plugins in later versions.
+
+### List of supported plugins
+
+* url-alias
+
+### example of using plugins
+
+```bash
+$ t4s --plugins url-alias
+```
+
+## Population
+
+If your content types contains relations, dynamic zones or media, the fields can be set to required in the same way as you would populate them in the strapi api.
+
+Here is an example if you have a content type name page, with a relation to a related page that you want the title and date of.
+
+```typescript
+type PageWithRelated = Page<'related_page.title' | 'related_page.date'>
+```
+
+This will make the title and date field on the new type required, so that you do not need to make an extra if check.
+NOTE: when doing this, you should also make sure that you are actually populating it the same way as in the api
+
+Other example using an array
+
+```typescript
+const populatedFields = ['related_page.title', 'related_page.date'] as const; // as const is important
+type PageWithRelated = Page<typeof populatedFields[number]>;
+```
 
 ## Tips and tricks
 

package/lib/attributes/Attributes.d.ts

@@ -0,0 +1,13 @@
+import { RelationNames } from '../file/File';
+export default class Attributes {
+    Attrs: Record<string, Record<string, any>>;
+    private RelationNames;
+    constructor(attr: Record<string, Record<string, any>>, relationNames: RelationNames);
+    isAttributePopulatable(attr: any): boolean;
+    hasPopulatableAttributes(): boolean;
+    getPopulatableAttributes(): Set<string>;
+    getDependencies(): string[];
+    attributeToString(attrName: string, attr: any): string;
+    toFieldsString(): string;
+    toString(): string;
+}

package/lib/attributes/Attributes.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var constants_1 = require("../constants");
+var Attributes = /** @class */ (function () {
+    function Attributes(attr, relationNames) {
+        this.RelationNames = {};
+        this.Attrs = attr;
+        this.RelationNames = relationNames;
+    }
+    Attributes.prototype.isAttributePopulatable = function (attr) {
+        // If it is a component / relation / dynamiczone it is always optional due to population
+        switch (attr.type) {
+            case 'nested':
+                // we need to check equality since it could be undefined
+                return attr.nullable === true;
+            case 'media': // media is also always populatable
+            case 'component':
+            case 'dynamiczone':
+            case 'relation':
+                return true;
+            default:
+                break;
+        }
+        return false;
+    };
+    Attributes.prototype.hasPopulatableAttributes = function () {
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            if (this.isAttributePopulatable(attr)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    Attributes.prototype.getPopulatableAttributes = function () {
+        var populatableAttributes = new Set();
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            if (this.isAttributePopulatable(attr)) {
+                populatableAttributes.add(attrName);
+            }
+        }
+        return populatableAttributes;
+    };
+    Attributes.prototype.getDependencies = function () {
+        var _a;
+        var dependencies = new Set();
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            switch (attr.type) {
+                case 'nested':
+                    var attrs = new Attributes(attr.fields, this.RelationNames);
+                    var deps = attrs.getDependencies();
+                    deps.forEach(function (dep) { return dependencies.add(dep); });
+                    break;
+                case 'relation':
+                    dependencies.add(attr.target);
+                    break;
+                case 'component':
+                    dependencies.add(attr.component);
+                    break;
+                case 'media':
+                    dependencies.add('builtins::Media');
+                    break;
+                case 'dynamiczone':
+                    var componentDeps = (_a = attr.components) !== null && _a !== void 0 ? _a : [];
+                    componentDeps.forEach(function (dep) { return dependencies.add(dep); });
+                    break;
+                default:
+                    continue;
+            }
+            // // If the current dependency is the interface itself, do not report it as a dependency
+            // if (dependencyName === strapiName) {
+            //     continue;
+            // }
+        }
+        if (this.hasPopulatableAttributes()) {
+            dependencies.add('builtins::ExtractNested');
+            dependencies.add('builtins::ExtractFlat');
+            dependencies.add('builtins::RequiredBy');
+        }
+        return Array.from(dependencies);
+    };
+    Attributes.prototype.attributeToString = function (attrName, attr) {
+        var _this = this;
+        var _a, _b, _c;
+        var isPopulatable = this.isAttributePopulatable(attr);
+        var isOptional = isPopulatable;
+        var optionalString = isOptional ? '?' : '';
+        var orNull = ' | null';
+        // TODO: only add this in non paranoid mode
+        /* const requiredString = attr.required !== true ? orNull : ''; */
+        var requiredString = orNull;
+        var str = "    ".concat(attrName).concat(optionalString, ": ");
+        var isArray = false;
+        switch (attr.type) {
+            // types-4-strapi-2 specific, used for builtin types
+            case 'nested':
+                // Be careful with recursion
+                // console.log(attr);
+                var nullableString = ((_a = attr === null || attr === void 0 ? void 0 : attr.nullable) !== null && _a !== void 0 ? _a : false) ? ' | null' : '';
+                var newAttrs = new Attributes(attr.fields, this.RelationNames);
+                str += newAttrs.toString() + nullableString;
+                break;
+            case 'relation':
+                var apiName = attr.target;
+                // console.log(this.RelationNames, apiName)
+                var dependencyName = (_c = (_b = this.RelationNames[apiName]) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'any';
+                var relationMultipleString = attr.relation.endsWith('ToMany')
+                    ? '[]'
+                    : orNull;
+                str += "{ data: ";
+                str += dependencyName;
+                // TODO: assert correctly
+                var relationInterface = this.RelationNames[apiName].file;
+                if (relationInterface.hasPopulatableAttributes()) {
+                    str += '<';
+                    str += "".concat(this.RelationNames['builtins::ExtractNested'].name, "<").concat(constants_1.POPULATE_GENERIC_NAME, ", '").concat(attrName, "'>");
+                    str += '>';
+                }
+                str += relationMultipleString;
+                str += "; }";
+                break;
+            case 'component':
+                var componentName = attr.component;
+                var relationNameObj = this.RelationNames[componentName];
+                /* console.log(this.RelationNames); */
+                var dependencyComponentName = relationNameObj.name;
+                /* isArray = attr.repeatable ?? false; */
+                isArray = false; // we already handle this here.
+                str += dependencyComponentName;
+                if (attr.repeatable) {
+                    str += '[]';
+                }
+                str += requiredString; // resolves #20. components can be null.
+                break;
+            case 'media':
+                var mediaMultipleString = attr.multiple
+                    ? '[]'
+                    : requiredString;
+                str += "{ data: ";
+                str += this.RelationNames['builtins::Media'].name;
+                str += mediaMultipleString;
+                str += "; }";
+                break;
+            case 'password':
+                return null;
+            case 'enumeration':
+                var hasDefault = 'default' in attr;
+                var enums = attr.enum.map(function (en) { return "\"".concat(en, "\""); });
+                enums.push('null');
+                var typeString = enums.join(' | ');
+                str += typeString;
+                break;
+            case 'dynamiczone':
+                // console.log(attr.components);
+                var relations = attr.components.map(function (componentName) {
+                    var component = _this.RelationNames[componentName];
+                    // in this context file should always be an interface
+                    var file = component.file;
+                    var populatable = file.hasPopulatableAttributes();
+                    /* false; */
+                    var populatableString = populatable
+                        ? "".concat(_this.RelationNames[componentName].name, "<").concat(_this.RelationNames['builtins::ExtractNested'].name, "<").concat(constants_1.POPULATE_GENERIC_NAME, ", '").concat(attrName, "'>>")
+                        : _this.RelationNames[componentName].name;
+                    return populatableString;
+                });
+                // console.log(relations);
+                var relationsString = relations.join(' | ');
+                // console.log(relationsString);
+                str += "Array<".concat(relationsString, ">");
+                break;
+            case 'string':
+            case 'text':
+            case 'richtext':
+            case 'email':
+            case 'uid':
+                str += 'string';
+                str += requiredString;
+                break;
+            case 'integer':
+            case 'biginteger':
+            case 'decimal':
+            case 'float':
+                str += 'number';
+                str += requiredString;
+                break;
+            case 'date':
+            case 'datetime':
+            case 'time':
+                str += 'string';
+                str += requiredString;
+                break;
+            case 'boolean':
+                str += attr.type;
+                str += requiredString;
+                break;
+            case 'json':
+            default:
+                str += 'any';
+                break;
+        }
+        var isArrayString = isArray ? '[]' : '';
+        str += "".concat(isArrayString, ";");
+        return str;
+    };
+    Attributes.prototype.toFieldsString = function () {
+        var strings = [];
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            var attrString = this.attributeToString(attrName, attr);
+            if (attrString === null) {
+                continue;
+            }
+            strings.push(attrString);
+        }
+        return strings.map(function (s) { return "".concat(s, "\n"); }).join('');
+    };
+    Attributes.prototype.toString = function () {
+        var strings = ['{'];
+        strings.push(this.toFieldsString());
+        strings.push('}');
+        return strings.join('\n');
+    };
+    return Attributes;
+}());
+exports.default = Attributes;

package/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const POPULATE_GENERIC_NAME = "Populate";

package/lib/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POPULATE_GENERIC_NAME = void 0;
+exports.POPULATE_GENERIC_NAME = 'Populate';

package/lib/content-types/reader.d.ts

@@ -0,0 +1,14 @@
+export declare function readSchema(schemaPath: string): Promise<any>;
+export declare function getApiFolders(strapiSrcRoot: string): Promise<string[]>;
+export declare function getComponentCategoryFolders(strapiSrcRoot: string): Promise<string[]>;
+export declare function getComponentSchemas(strapiSrcRoot: string): Promise<{
+    category: string;
+    schemas: {
+        name: string;
+        attributes: any;
+    }[];
+}[]>;
+export declare function getApiSchemas(strapiSrcRoot: string): Promise<{
+    name: string;
+    attributes: any;
+}[]>;

package/lib/content-types/reader.js

@@ -0,0 +1,177 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiSchemas = exports.getComponentSchemas = exports.getComponentCategoryFolders = exports.getApiFolders = exports.readSchema = void 0;
+var node_fs_1 = require("node:fs");
+var promises_1 = require("node:fs/promises");
+var posix_1 = require("node:path/posix");
+var utils_1 = require("../utils");
+function readSchema(schemaPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schemaData, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, (0, promises_1.readFile)(schemaPath)];
+                case 1:
+                    schemaData = _a.sent();
+                    return [2 /*return*/, JSON.parse(schemaData.toString()).attributes];
+                case 2:
+                    e_1 = _a.sent();
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.readSchema = readSchema;
+function getApiFolders(strapiSrcRoot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var path, folders;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    path = (0, posix_1.join)(strapiSrcRoot, 'api');
+                    return [4 /*yield*/, (0, utils_1.readDirFiltered)(path)];
+                case 1:
+                    folders = _a.sent();
+                    return [2 /*return*/, folders];
+            }
+        });
+    });
+}
+exports.getApiFolders = getApiFolders;
+function getComponentCategoryFolders(strapiSrcRoot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var path, folders;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    path = (0, posix_1.join)(strapiSrcRoot, 'components');
+                    // If there exists no components, just fallback to an empty array.
+                    if (!(0, node_fs_1.existsSync)(path)) {
+                        return [2 /*return*/, []];
+                    }
+                    return [4 /*yield*/, (0, utils_1.readDirFiltered)(path)];
+                case 1:
+                    folders = _a.sent();
+                    return [2 /*return*/, folders];
+            }
+        });
+    });
+}
+exports.getComponentCategoryFolders = getComponentCategoryFolders;
+function getComponentSchemas(strapiSrcRoot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var categories, nestedSchemasPromises, nestedSchemasArr;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getComponentCategoryFolders(strapiSrcRoot)];
+                case 1:
+                    categories = _a.sent();
+                    nestedSchemasPromises = categories.map(function (category) { return __awaiter(_this, void 0, void 0, function () {
+                        var schemaFilesPath, schemaFiles, schemaNamesWithAttributesPromises, schemaNamesWithAttributes;
+                        var _this = this;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    schemaFilesPath = (0, posix_1.join)(strapiSrcRoot, 'components', category);
+                                    return [4 /*yield*/, (0, utils_1.readDirFiltered)(schemaFilesPath)];
+                                case 1:
+                                    schemaFiles = _a.sent();
+                                    schemaNamesWithAttributesPromises = schemaFiles.map(function (file) { return __awaiter(_this, void 0, void 0, function () {
+                                        var schemaPath, attributes, name;
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0:
+                                                    schemaPath = (0, posix_1.join)(schemaFilesPath, file);
+                                                    return [4 /*yield*/, readSchema(schemaPath)];
+                                                case 1:
+                                                    attributes = _a.sent();
+                                                    name = file.split('.')[0];
+                                                    return [2 /*return*/, { name: name, attributes: attributes }];
+                                            }
+                                        });
+                                    }); });
+                                    return [4 /*yield*/, Promise.all(schemaNamesWithAttributesPromises)];
+                                case 2:
+                                    schemaNamesWithAttributes = _a.sent();
+                                    return [2 /*return*/, { category: category, schemas: schemaNamesWithAttributes }];
+                            }
+                        });
+                    }); });
+                    return [4 /*yield*/, Promise.all(nestedSchemasPromises)];
+                case 2:
+                    nestedSchemasArr = _a.sent();
+                    return [2 /*return*/, nestedSchemasArr];
+            }
+        });
+    });
+}
+exports.getComponentSchemas = getComponentSchemas;
+function getApiSchemas(strapiSrcRoot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var apiFolders, schemasWithAttributesPromises, schemasWithAttributes;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getApiFolders(strapiSrcRoot)];
+                case 1:
+                    apiFolders = _a.sent();
+                    schemasWithAttributesPromises = apiFolders.map(function (folder) { return __awaiter(_this, void 0, void 0, function () {
+                        var schemaPath, attributes;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    schemaPath = (0, posix_1.join)(strapiSrcRoot, 'api', folder, 'content-types', folder, 'schema.json');
+                                    return [4 /*yield*/, readSchema(schemaPath)];
+                                case 1:
+                                    attributes = _a.sent();
+                                    return [2 /*return*/, { name: folder, attributes: attributes }];
+                            }
+                        });
+                    }); });
+                    schemasWithAttributes = Promise.all(schemasWithAttributesPromises);
+                    return [2 /*return*/, schemasWithAttributes];
+            }
+        });
+    });
+}
+exports.getApiSchemas = getApiSchemas;

package/lib/extra-types/ExtraType.d.ts

@@ -0,0 +1,11 @@
+import { File } from "../file/File";
+import { caseType } from "../utils/casing";
+export declare class ExtraType extends File {
+    protected typeString: string;
+    constructor(typeString: string, baseName: string, relativeDirectoryPath: string, fileCaseType?: caseType);
+    getDependencies(): any[];
+    getStrapiName(): string;
+    getFullName(): string;
+    protected updateStrapiName(): void;
+    toString(): string;
+}

package/lib/extra-types/ExtraType.js

@@ -0,0 +1,47 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtraType = void 0;
+var File_1 = require("../file/File");
+var ExtraType = /** @class */ (function (_super) {
+    __extends(ExtraType, _super);
+    function ExtraType(typeString, baseName, relativeDirectoryPath, fileCaseType) {
+        if (fileCaseType === void 0) { fileCaseType = 'pascal'; }
+        var _this = _super.call(this, baseName, relativeDirectoryPath, fileCaseType) || this;
+        _this.typeString = typeString;
+        _this.updateStrapiName();
+        return _this;
+    }
+    ExtraType.prototype.getDependencies = function () {
+        return [];
+    };
+    ExtraType.prototype.getStrapiName = function () {
+        return this.StrapiName;
+    };
+    ExtraType.prototype.getFullName = function () {
+        return this.BaseName;
+    };
+    ExtraType.prototype.updateStrapiName = function () {
+        this.StrapiName = "builtins::".concat(this.BaseName);
+    };
+    ExtraType.prototype.toString = function () {
+        // TODO: make this more dynamic
+        return "export ".concat(this.typeString);
+    };
+    return ExtraType;
+}(File_1.File));
+exports.ExtraType = ExtraType;

package/lib/extra-types/createExtraTypes.d.ts

@@ -0,0 +1,2 @@
+import { ExtraType } from "./ExtraType";
+export declare const createExtraTypes: () => ExtraType[];

package/lib/extra-types/createExtraTypes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExtraTypes = void 0;
+var ExtraType_1 = require("./ExtraType");
+/* const requiredByString = `type RequiredBy<T, K extends string> = Required<Pick<T, K>> & Omit<T, K>;`; */
+var requiredByString = "type RequiredBy<T, K extends string> = Required<Pick<T, Extract<K, keyof T>>> & Omit<T, Extract<K, keyof T>>;";
+var extractNestedString = 'type ExtractNested<T, K extends string> = T extends `${K}.${infer U}` ? U : never;';
+var extractFlatString = 'type ExtractFlat<T extends string> = T extends `${infer U}.${string}` ? U : T;';
+var extraTypeData = {
+    'RequiredBy': requiredByString,
+    'ExtractNested': extractNestedString,
+    'ExtractFlat': extractFlatString,
+};
+var createExtraTypes = function () {
+    return Object.entries(extraTypeData).map(function (_a) {
+        var name = _a[0], typeString = _a[1];
+        var extraType = new ExtraType_1.ExtraType(typeString, name, 'builtins');
+        return extraType;
+    });
+};
+exports.createExtraTypes = createExtraTypes;

package/lib/file/File.d.ts

@@ -0,0 +1,26 @@
+import { caseType } from "../utils/casing";
+export declare type RelationNames = Record<string, {
+    name: string;
+    file: File;
+}>;
+export declare abstract class File {
+    private Relations;
+    protected RelationNames: RelationNames;
+    private RelationNamesCounter;
+    protected BaseName: string;
+    protected StrapiName: string;
+    private RelativeDirectoryPath;
+    protected FileCase: caseType;
+    constructor(baseName: string, relativeDirectoryPath: string, fileCaseType?: caseType);
+    abstract getDependencies(): string[];
+    abstract getStrapiName(): string;
+    abstract getFullName(): string;
+    abstract toString(): string;
+    setRelations(relations: File[]): void;
+    getRelativeRootPath(): any;
+    getBaseName(): string;
+    getRelativeRootPathFile(): string;
+    getRelativeRootDir(): string;
+    getFileBaseName(): string;
+    protected getTsImports(): string;
+}