@oak-digital/types-4-strapi-2 0.5.4 → 1.0.0-beta.1

package/lib/extra-types/ExtraType.js

@@ -1,47 +1,28 @@
 "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;
+const File_1 = require("../file/File");
+class ExtraType extends File_1.File {
+    constructor(typeString, baseName, relativeDirectoryPath, fileCaseType = 'pascal') {
+        super(baseName, relativeDirectoryPath, fileCaseType);
+        this.typeString = typeString;
+        this.updateStrapiName();
     }
-    ExtraType.prototype.getDependencies = function () {
+    getDependencies() {
         return [];
-    };
-    ExtraType.prototype.getStrapiName = function () {
+    }
+    getStrapiName() {
         return this.StrapiName;
-    };
-    ExtraType.prototype.getFullName = function () {
+    }
+    getFullName() {
         return this.BaseName;
-    };
-    ExtraType.prototype.updateStrapiName = function () {
-        this.StrapiName = "builtins::".concat(this.BaseName);
-    };
-    ExtraType.prototype.toString = function () {
+    }
+    updateStrapiName() {
+        this.StrapiName = `builtins::${this.BaseName}`;
+    }
+    toString() {
         // TODO: make this more dynamic
-        return "export ".concat(this.typeString);
-    };
-    return ExtraType;
-}(File_1.File));
+        return `export ${this.typeString}`;
+    }
+}
 exports.ExtraType = ExtraType;

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

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

package/lib/extra-types/createExtraTypes.js

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

package/lib/file/File.d.ts

@@ -1,4 +1,4 @@
-import { caseType } from "../utils/casing";
+import { caseType } from '../utils/casing';
 export declare type RelationNames = Record<string, {
     name: string;
     file: File;

package/lib/file/File.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.File = void 0;
-var utils_1 = require("../utils");
-var posix_1 = require("path/posix");
-var casing_1 = require("../utils/casing");
-var File = /** @class */ (function () {
-    function File(baseName, relativeDirectoryPath, fileCaseType) {
-        if (fileCaseType === void 0) { fileCaseType = 'pascal'; }
+const utils_1 = require("../utils");
+const posix_1 = require("path/posix");
+const casing_1 = require("../utils/casing");
+class File {
+    constructor(baseName, relativeDirectoryPath, fileCaseType = 'pascal') {
         this.Relations = []; // Components and relations
         this.RelationNames = {};
         this.RelationNamesCounter = {};
@@ -15,58 +14,60 @@ var File = /** @class */ (function () {
         this.FileCase = fileCaseType;
         this.RelativeDirectoryPath = relativeDirectoryPath;
     }
-    File.prototype.setRelations = function (relations) {
-        var _this = this;
+    setRelations(relations) {
         this.Relations = relations;
         this.RelationNames = {};
         this.RelationNamesCounter = {};
-        this.Relations.forEach(function (file) {
-            var name = file.getFullName();
+        this.Relations.forEach((file) => {
+            let name = file.getFullName();
             // FIXME: clean up this mess...
-            if (file.getStrapiName() !== _this.getStrapiName()) {
+            if (file.getStrapiName() !== this.getStrapiName()) {
                 // Avoid duplicate names
-                if (name in _this.RelationNamesCounter) {
-                    name += ++_this.RelationNamesCounter[name];
+                if (name in this.RelationNamesCounter) {
+                    name += ++this.RelationNamesCounter[name];
                 }
                 else {
-                    _this.RelationNamesCounter[name] = 0;
+                    this.RelationNamesCounter[name] = 0;
                 }
             }
-            _this.RelationNames[file.getStrapiName()] = { name: name, file: file };
+            this.RelationNames[file.getStrapiName()] = { name, file };
         });
-    };
+    }
     // For typescript import from index file
-    File.prototype.getRelativeRootPath = function () {
-        var path = (0, posix_1.join)(this.RelativeDirectoryPath, this.getFileBaseName());
+    getRelativeRootPath() {
+        const path = (0, posix_1.join)(this.RelativeDirectoryPath, this.getFileBaseName());
         return (0, utils_1.prefixDotSlash)(path);
-    };
-    File.prototype.getBaseName = function () {
+    }
+    getBaseName() {
         return this.BaseName;
-    };
-    File.prototype.getRelativeRootPathFile = function () {
-        return "".concat(this.getRelativeRootPath(), ".ts");
-    };
-    File.prototype.getRelativeRootDir = function () {
-        var path = (0, posix_1.dirname)(this.getRelativeRootPathFile());
+    }
+    getRelativeRootPathFile() {
+        return `${this.getRelativeRootPath()}.ts`;
+    }
+    getRelativeRootDir() {
+        const path = (0, posix_1.dirname)(this.getRelativeRootPathFile());
         return path;
-    };
-    File.prototype.getFileBaseName = function () {
+    }
+    getFileBaseName() {
         return (0, casing_1.changeCase)(this.getBaseName(), this.FileCase);
-    };
-    File.prototype.getTsImports = function () {
-        var _this = this;
-        return Object.keys(this.RelationNames).map(function (strapiName) {
-            if (strapiName === _this.getStrapiName()) {
+    }
+    getTsImports() {
+        return Object.keys(this.RelationNames)
+            .map((strapiName) => {
+            if (strapiName === this.getStrapiName()) {
                 return '';
             }
-            var relationName = _this.RelationNames[strapiName].name;
-            var inter = _this.RelationNames[strapiName].file;
-            var importPath = (0, utils_1.prefixDotSlash)((0, posix_1.relative)(_this.getRelativeRootDir(), inter.getRelativeRootPath()));
-            var fullName = inter.getFullName();
-            var importNameString = fullName === relationName ? fullName : "".concat(fullName, " as ").concat(relationName);
-            return "import { ".concat(importNameString, " } from '").concat(importPath, "';");
-        }).filter(function (s) { return s; }).join('\n');
-    };
-    return File;
-}());
+            const relationName = this.RelationNames[strapiName].name;
+            const inter = this.RelationNames[strapiName].file;
+            const importPath = (0, utils_1.prefixDotSlash)((0, posix_1.relative)(this.getRelativeRootDir(), inter.getRelativeRootPath()));
+            const fullName = inter.getFullName();
+            const importNameString = fullName === relationName
+                ? fullName
+                : `${fullName} as ${relationName}`;
+            return `import { ${importNameString} } from '${importPath}';`;
+        })
+            .filter((s) => s)
+            .join('\n');
+    }
+}
 exports.File = File;

package/lib/index.js

@@ -1,15 +1,28 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var commander_1 = require("commander");
-var InterfaceManager_1 = __importDefault(require("./program/InterfaceManager"));
-commander_1.program
-    .name('t4s');
+const commander_1 = require("commander");
+const InterfaceManager_1 = __importDefault(require("./program/InterfaceManager"));
+const by_file_1 = require("./readers/by-file");
+const basic_writer_1 = require("./writers/basic-writer");
+const prettier_1 = __importDefault(require("prettier"));
+const load_strapi_1 = require("./readers/load-strapi");
+commander_1.program.name('t4s');
 commander_1.program
-    .option('-i, --in <dir>', 'The src directory for strapi', './src')
+    .option('-i, --in <dir>', 'The root directory for strapi', './')
     .option('-o, --out <dir>', 'The output directory to output the types to', './types')
+    .option('-r, --reader <reader>', 'The reader to use (possible: by-file, load-strapi. See docs for more info)', 'by-file')
     .option('--prefix <prefix>', 'A prefix for all generated interfaces', 'I')
     .option('--component-prefix <prefix>', 'A prefix for components', '')
     .option('-D, --delete-old', 'CAUTION: This option is equivalent to running rm -rf on the output directory first')
@@ -18,17 +31,42 @@ commander_1.program
     .option('--plugins <plugins...>', 'A list of enabled plugins in the target strapi project that modify content-types')
     .option('--prettier <file>', 'The prettier config file to use for formatting typescript interfaces');
 commander_1.program.parse();
-var options = commander_1.program.opts();
-var input = options.in, out = options.out, componentPrefix = options.componentPrefix, prefix = options.prefix, prettierFile = options.prettier, deleteOld = options.deleteOld, fileCaseType = options.fileCase, folderCaseType = options.folderCase, plugins = options.plugins;
-var manager = new InterfaceManager_1.default(out, input, {
-    componentPrefix: componentPrefix,
-    prefix: prefix,
-    prettierFile: prettierFile,
-    deleteOld: deleteOld,
-    fileCaseType: fileCaseType,
-    folderCaseType: folderCaseType,
-    enabledPlugins: plugins,
-});
-manager.run().catch(function (err) {
-    console.error(err);
-});
+const options = commander_1.program.opts();
+const { in: input, out, componentPrefix, prefix, prettier: prettierFile, deleteOld, fileCase: fileCaseType, folderCase: folderCaseType, plugins, reader: readerName, } = options;
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const defaultPrettierOptions = {
+        parser: 'typescript',
+    };
+    let prettierOptions = defaultPrettierOptions;
+    if (prettierFile) {
+        const resolved = yield prettier_1.default.resolveConfig(prettierFile, {
+            editorconfig: true,
+        });
+        prettierOptions = Object.assign(Object.assign({}, defaultPrettierOptions), resolved);
+    }
+    let reader;
+    switch (readerName) {
+        case 'by-file':
+            reader = new by_file_1.ByFileContentTypeReader(input);
+            break;
+        case 'load-strapi':
+            reader = new load_strapi_1.LoadStrapiReader(input);
+            break;
+        default:
+            throw new Error(`Unknown reader: ${readerName}`);
+    }
+    const writer = new basic_writer_1.BasicWriter(out, {
+        deleteOld,
+        prettierOptions,
+    });
+    const manager = new InterfaceManager_1.default(reader, writer, {
+        componentPrefix,
+        prefix,
+        fileCaseType,
+        folderCaseType,
+        enabledPlugins: plugins,
+    });
+    manager.run().catch((err) => {
+        console.error(err);
+    });
+}))();

package/lib/interface/BuiltinComponentInterface.js

@@ -1,36 +1,18 @@
 "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 __());
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var ComponentInterface_1 = __importDefault(require("./ComponentInterface"));
-var BuiltinComponentInterface = /** @class */ (function (_super) {
-    __extends(BuiltinComponentInterface, _super);
-    function BuiltinComponentInterface(baseName, attributes, relativeDirectoryPath, fileCase, prefix) {
-        if (prefix === void 0) { prefix = ''; }
-        return _super.call(this, baseName, attributes, relativeDirectoryPath, 'builtins', fileCase, prefix, {
+const ComponentInterface_1 = __importDefault(require("./ComponentInterface"));
+class BuiltinComponentInterface extends ComponentInterface_1.default {
+    constructor(baseName, attributes, relativeDirectoryPath, fileCase, prefix = '') {
+        super(baseName, 'builtins', attributes, relativeDirectoryPath, '', fileCase, prefix, {
             hasId: false,
             hasComponent: false,
-        }) || this;
+        });
     }
-    BuiltinComponentInterface.prototype.updateStrapiName = function () {
-        this.StrapiName = "builtins::".concat(this.BaseName);
-    };
-    return BuiltinComponentInterface;
-}(ComponentInterface_1.default));
+    updateStrapiName() {
+        this.StrapiName = `builtins::${this.BaseName}`;
+    }
+}
 exports.default = BuiltinComponentInterface;

package/lib/interface/BuiltinInterface.d.ts

@@ -2,5 +2,4 @@ import { caseType } from '../utils/casing';
 import Interface from './Interface';
 export default class BuiltinInterface extends Interface {
     constructor(baseName: string, attributes: any, relativeDirectoryPath: string, fileCase: caseType, prefix?: string);
-    updateStrapiName(): void;
 }

package/lib/interface/BuiltinInterface.js

@@ -1,33 +1,12 @@
 "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 __());
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var Interface_1 = __importDefault(require("./Interface"));
-var BuiltinInterface = /** @class */ (function (_super) {
-    __extends(BuiltinInterface, _super);
-    function BuiltinInterface(baseName, attributes, relativeDirectoryPath, fileCase, prefix) {
-        if (prefix === void 0) { prefix = ''; }
-        return _super.call(this, baseName, attributes, relativeDirectoryPath, fileCase, prefix) || this;
+const Interface_1 = __importDefault(require("./Interface"));
+class BuiltinInterface extends Interface_1.default {
+    constructor(baseName, attributes, relativeDirectoryPath, fileCase, prefix = '') {
+        super(baseName, 'builtins', attributes, relativeDirectoryPath, null, fileCase, prefix);
     }
-    BuiltinInterface.prototype.updateStrapiName = function () {
-        this.StrapiName = "builtins::".concat(this.BaseName);
-    };
-    return BuiltinInterface;
-}(Interface_1.default));
+}
 exports.default = BuiltinInterface;

package/lib/interface/ComponentInterface.d.ts

@@ -1,9 +1,10 @@
+import { Namespace } from '../readers/types/content-type-reader';
 import { caseType } from '../utils/casing';
 import Interface from './Interface';
 export default class ComponentInterface extends Interface {
     protected Category: string;
     protected Options: Record<string, any>;
-    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, category: string, fileCase: caseType, prefix?: string, options?: Record<string, any>);
+    constructor(baseName: string, namespace: Namespace, attributes: any, relativeDirectoryPath: string, category: string, fileCase: caseType, prefix?: string, options?: Record<string, any>);
     updateStrapiName(): void;
     getInerfaceString(): string;
     getInterfaceFieldsString(): string;

package/lib/interface/ComponentInterface.js

@@ -1,61 +1,44 @@
 "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 __());
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("../constants");
-var Interface_1 = __importDefault(require("./Interface"));
-var ComponentInterface = /** @class */ (function (_super) {
-    __extends(ComponentInterface, _super);
-    function ComponentInterface(baseName, attributes, relativeDirectoryPath, category, fileCase, prefix, options) {
-        if (prefix === void 0) { prefix = ''; }
-        if (options === void 0) { options = {}; }
-        var _this = _super.call(this, baseName, attributes, relativeDirectoryPath, fileCase, prefix) || this;
-        _this.Options = {
+const constants_1 = require("../constants");
+const Interface_1 = __importDefault(require("./Interface"));
+class ComponentInterface extends Interface_1.default {
+    constructor(baseName, namespace, attributes, relativeDirectoryPath, category, fileCase, prefix = '', options = {}) {
+        // TODO: Component interface doesn't really make sense to extend from Interface, but it works for now.
+        //       we should transition to use composition instead of this type of inheritance
+        super(baseName, namespace, attributes, relativeDirectoryPath, category, fileCase, prefix);
+        this.Options = {
             hasId: true,
             hasComponent: true,
         };
-        _this.Category = category;
+        this.Category = category;
         // this.Attributes.id = {
         //     type: "number", // Components have a id field with a number
         //     required: true,
         // };
-        _this.updateStrapiName();
-        Object.assign(_this.Options, options);
-        return _this;
+        this.updateStrapiName();
+        Object.assign(this.Options, options);
+    }
+    updateStrapiName() {
+        this.StrapiName = `${this.Category}.${this.getBaseName()}`;
     }
-    ComponentInterface.prototype.updateStrapiName = function () {
-        this.StrapiName = "".concat(this.Category, ".").concat(this.getBaseName());
-    };
     // TODO: make this more dynamic in parent
-    ComponentInterface.prototype.getInerfaceString = function () {
-        var isPopulatable = this.hasPopulatableAttributes();
+    getInerfaceString() {
+        const isPopulatable = this.hasPopulatableAttributes();
         /* const populateString = isPopulatable ? `<${POPULATE_GENERIC_NAME} extends string | never = never>` : ''; */
-        var strArr = [];
+        const strArr = [];
         if (isPopulatable) {
-            strArr.push("export type ".concat(this.getFullName()));
+            strArr.push(`export type ${this.getFullName()}`);
         }
         else {
-            strArr.push("export interface ".concat(this.getFullName()));
+            strArr.push(`export interface ${this.getFullName()}`);
         }
         if (isPopulatable) {
-            strArr.push("<".concat(constants_1.POPULATE_GENERIC_NAME, " extends string | never = never>"));
-            strArr.push(" = ".concat(this.RelationNames['builtins::RequiredBy'].name, "<"));
+            strArr.push(`<${constants_1.POPULATE_GENERIC_NAME} extends string | never = never>`);
+            strArr.push(` = ${this.RelationNames['builtins::RequiredBy'].name}<`);
         }
         strArr.push(' {\n');
         strArr.push(this.getInterfaceFieldsString());
@@ -71,21 +54,20 @@ var ComponentInterface = /** @class */ (function (_super) {
             // required by end
             strArr.push('>');
         }
-        var str = strArr.join('');
+        const str = strArr.join('');
         return str;
-    };
-    ComponentInterface.prototype.getInterfaceFieldsString = function () {
-        var attrs = this.getAttributes();
-        var str = '';
-        var _a = this.Options, hasId = _a.hasId, hasComponent = _a.hasComponent;
+    }
+    getInterfaceFieldsString() {
+        const attrs = this.getAttributes();
+        let str = '';
+        const { hasId, hasComponent } = this.Options;
         if (hasId) {
             str += '  id: number;\n';
         }
         if (hasComponent) {
-            str += "  __component: \"".concat(this.getStrapiName(), "\";\n");
+            str += `  __component: "${this.getStrapiName()}";\n`;
         }
         return str + attrs.toFieldsString();
-    };
-    return ComponentInterface;
-}(Interface_1.default));
+    }
+}
 exports.default = ComponentInterface;

package/lib/interface/Interface.d.ts

@@ -1,10 +1,14 @@
 import { caseType } from '../utils/casing';
 import Attributes from '../attributes/Attributes';
 import { File } from '../file/File';
+import { AttributeWithNested } from './builtinInterfaces';
+import { Namespace } from '../readers/types/content-type-reader';
 export default class Interface extends File {
     private NamePrefix;
-    protected Attributes: any;
-    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, fileCaseType?: caseType, prefix?: string);
+    protected Attributes: Record<string, AttributeWithNested>;
+    protected CollectionName: string | null;
+    protected Namespace: Namespace;
+    constructor(baseName: string, namespace: Namespace, attributes: Record<string, AttributeWithNested>, relativeDirectoryPath: string, collectionName?: string | null, fileCaseType?: caseType, prefix?: string);
     protected updateStrapiName(): void;
     getStrapiName(): string;
     getDependencies(): string[];