@sap/artifact-management 1.0.1 → 1.1.3

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ItemLink.d.ts

@@ -0,0 +1,24 @@
+export declare enum LinkType {
+    DEPENDS_ON = "DEPENDS_ON",
+    HAS_DEPENDENCY = "HAS_DEPENDENCY",
+    TRANSITIVELY_DEPENDS_ON = "TRANSITIVELY_DEPENDS_ON",
+    HAS_TRANSITIVE_DEPENDENCY = "HAS_TRANSITIVE_DEPENDENCY",
+    PARENT_OF = "PARENT_OF",
+    CHILD_OF = "CHILD_OF"
+}
+export declare const LinkTypeReverse: {
+    CHILD_OF: LinkType;
+    PARENT_OF: LinkType;
+    DEPENDS_ON: LinkType;
+    HAS_DEPENDENCY: LinkType;
+    TRANSITIVELY_DEPENDS_ON: LinkType;
+    HAS_TRANSITIVE_DEPENDENCY: LinkType;
+};
+export default interface ItemLink {
+    /** Link type */
+    linkType: LinkType;
+    /** Target type  */
+    type: string;
+    /** Target reference */
+    ref: string;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ItemReader.d.ts

@@ -0,0 +1,13 @@
+import Item from './Item';
+import ProjectEntityReader from '../project-api/ProjectEntityReader';
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+/**
+ * Reader for entities of one or more types
+ */
+export default interface ItemReader extends ProjectEntityReader<Item[]> {
+    /**
+     * Super set of all item types that the reader may return
+     */
+    types: string[];
+    detailInfo?(fsPath: ProjectFileSystem, ref: string): Promise<Item | undefined>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/Message.d.ts

@@ -0,0 +1,11 @@
+import { DiagnosticSeverity, Range } from 'vscode-languageserver-types';
+export declare type Location = {
+    path: string;
+    range?: Range;
+};
+export default interface Message {
+    source?: string;
+    message: string;
+    severity: DiagnosticSeverity;
+    causedBy?: Error;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/Module.d.ts

@@ -0,0 +1,21 @@
+import Item from './Item';
+import ModuleData from './ModuleData';
+export default interface Module extends ModuleData {
+    items: Item[];
+}
+export declare type MtaModule = {
+    name: string;
+    type: string;
+    path?: string;
+    requires?: any;
+    provides?: any;
+    parameters?: any;
+    'build-parameters'?: any;
+};
+export declare type MtaModuleRequires = {
+    serviceName?: string;
+    servicePlan?: string;
+    parameters?: any;
+    name?: string;
+    optional?: any;
+};

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ModuleAutoBuilder.d.ts

@@ -0,0 +1,14 @@
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+import IProjectInstance from './IProjectInstance';
+import { KeyIn } from '../util/Types';
+import { ModuleType } from '../definitions/ModuleType';
+/**
+ * Automatically build files
+ *
+ */
+export default class ModuleAutoBuilder {
+    getType(): KeyIn<typeof ModuleType>;
+    patterns(): string[];
+    runInitial(fs: ProjectFileSystem, project: IProjectInstance): Promise<void>;
+    runUpdate(fs: ProjectFileSystem, project: IProjectInstance): Promise<void>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ModuleData.d.ts

@@ -0,0 +1,27 @@
+import { StateMessage } from '../commons/StateMessage';
+/**
+ * Modules organize content of a specific type, for example Fiori Element UIs or CAP service definitions, in a project.
+ * Modules are always associated with one directory.
+ */
+export default interface ModuleData {
+    /**
+     * Module type
+     */
+    type: string;
+    /**
+     * Module display name
+     */
+    name: string;
+    /**
+     * Module path
+     */
+    path: string;
+    /**
+     * Tags related to the Module
+     */
+    tags: string[];
+    /**
+     * Info messages
+     */
+    info?: StateMessage[];
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ModuleGeneratorContext.d.ts

@@ -0,0 +1,16 @@
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+import NameFactory from '../cp/NameFactory';
+import { Service } from '../cp/Service';
+import Module, { MtaModule } from './Module';
+import Project from './Project';
+export declare class ModuleGeneratorContext {
+    project: Project;
+    projectFs: ProjectFileSystem;
+    module?: Module;
+    services: Service[];
+    builtModules: MtaModule[];
+    [key: string]: any;
+    nameFactory: NameFactory;
+    constructor(project: Project, projectFs: ProjectFileSystem, nameFactory: NameFactory, module?: Module, services?: Service[]);
+    fs(): ProjectFileSystem;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ModuleManifestGenerator.d.ts

@@ -0,0 +1,12 @@
+import { Service } from '../cp/Service';
+import { MtaModuleRequires, MtaModule } from './Module';
+import { ModuleType } from '../definitions/ModuleType';
+import { ModuleGeneratorContext } from './ModuleGeneratorContext';
+import { KeyIn } from '../util/Types';
+export default interface ModuleManifestGenerator {
+    getType: () => KeyIn<typeof ModuleType>;
+    beforeBuildCommands(context?: ModuleGeneratorContext): Promise<string[]>;
+    provideResources: (context: ModuleGeneratorContext) => Promise<Service[]>;
+    getModuleManifest: (context: ModuleGeneratorContext) => Promise<MtaModule | null>;
+    requires: (context: ModuleGeneratorContext) => MtaModuleRequires[];
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ModuleReader.d.ts

@@ -0,0 +1,43 @@
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+import ItemReader from './ItemReader';
+import ProjectEntityReader, { ProjectEntityMatchConditions, ProjectEntityReaderReadOptions } from '../project-api/ProjectEntityReader';
+import ModuleData from './ModuleData';
+import { ModuleType } from '../definitions/ModuleType';
+import { DetectionMechanism } from './PluginEntryTypes';
+import { KeyIn } from '../util/Types';
+export interface ModuleReaderOptions {
+    fs: ProjectFileSystem;
+}
+export interface ModuleEntry {
+    fs: ProjectFileSystem;
+    pattern: string[];
+    type: string;
+}
+/**
+ * Read modules and its entities
+ *
+ * There are two ways to implement a ModuleReader:
+ * 1. Read complete module and entities in one call --> re-implement read()
+ * 2. Read module header and entities separately --> re-implement readModule()
+ *
+ * In both cases entityReaders() should return the entity readers with the super set of their handled types and tags and
+ * the relevant file pattern to recognize changes. This is relevant to have a fast project update in BAS.
+ */
+export declare abstract class ModuleReader implements ProjectEntityReader<ModuleData> {
+    static readonly type = "sap.project.plugin.type.module-reader";
+    moduleType: string | undefined;
+    readonly matchConditions: ProjectEntityMatchConditions;
+    itemReaders: ItemReader[];
+    abstract getType(): KeyIn<typeof ModuleType>;
+    abstract getDetectionMechanism(): DetectionMechanism;
+    tags: string[];
+    /**
+     *
+     * @param fs
+     *
+     * Read module header information (without entities).
+     *
+     * Re-implement this method if the module header and its entities should be read separately.
+     */
+    read(options: ProjectEntityReaderReadOptions): Promise<ModuleData | undefined>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/NodePackage.d.ts

@@ -0,0 +1,19 @@
+export declare type StringMap = {
+    [key: string]: string;
+};
+export interface NodePackage {
+    lcap: boolean;
+    cds: any;
+    name: string;
+    version: string;
+    dependencies: StringMap;
+    devDependencies: StringMap;
+    'sap.project': {
+        type?: string;
+        plugins?: string[];
+        properties?: StringMap;
+    };
+    'sap.project.module': {
+        type?: string;
+    };
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/Plugin.d.ts

@@ -0,0 +1,76 @@
+import RunUI from '../cp/RunUI';
+import ModuleAutoBuilder from './ModuleAutoBuilder';
+import ProjectManifestGenerator from './ProjectManifestGenerator';
+import ModuleManifestGenerator from './ModuleManifestGenerator';
+import ProjectRunner from './ProjectRunner';
+import { ProjectReader } from './ProjectReader';
+import { ModuleReader } from './ModuleReader';
+export declare enum DestinationType {
+    DEST_TO_SERVICE_INSTANCE = 0,
+    DEST_TO_RESOURCE_BEHIND_XSUAA = 1,
+    DEST_TO_SERVICE_INSTANCE_NO_CLOUD = 2
+}
+export declare enum AuthenticationType {
+    OAuth2UserTokenExchange = "OAuth2UserTokenExchange"
+}
+export declare enum ServiceType {
+    CF_MANAGED_SERVICE = "org.cloudfoundry.managed-service",
+    CAP_SERVICE = "org.sap.capservice",
+    CF_USER_PROVIDED_SERVICE = "org.cloudfoundry.user-provided-service"
+}
+export declare enum MtaModuleType {
+    APPLICATION_CONTENT = "com.sap.application.content",
+    HTML5 = "html5"
+}
+declare type ServiceAttribute = {
+    name: string;
+    plan: string;
+};
+declare type AvailableCatalog = {
+    xsuaa: ServiceAttribute;
+    destination: ServiceAttribute;
+    hana: ServiceAttribute;
+    workflow: ServiceAttribute;
+    html5_apps_repo_host: ServiceAttribute;
+    html5_apps_repo_runtime: ServiceAttribute;
+    capservice: ServiceAttribute;
+    document: ServiceAttribute;
+    metadata: ServiceAttribute;
+    connectivity: ServiceAttribute;
+};
+export declare const ServiceCatalog: AvailableCatalog;
+export declare type Route = {
+    source: string;
+    target: string;
+    service?: string;
+    destination?: string;
+    authenticationType: string;
+};
+export declare type XSAppJson = {
+    authenticationMethod: string;
+    logout: any;
+    routes: [Route?];
+};
+export interface IPlugin {
+    readonly name: string;
+    getDependencies(): string[];
+    getProjectReaders?(): ProjectReader[];
+    getModuleReaders?(): ModuleReader[];
+    getProjectManifestGenerators?(): ProjectManifestGenerator[];
+    getModuleManifestGenerators?(): ModuleManifestGenerator[];
+    getProjectRunner?(): ProjectRunner;
+    getModuleRunner?(): RunUI;
+    getModuleBuilder?(): ModuleAutoBuilder;
+}
+export declare abstract class Plugin implements IPlugin {
+    abstract name: string;
+    getDependencies(): string[];
+    getProjectReaders?(): ProjectReader[];
+    getModuleReaders?(): ModuleReader[];
+    getProjectManifestGenerators?(): ProjectManifestGenerator[];
+    getModuleManifestGenerators?(): ModuleManifestGenerator[];
+    getProjectRunner?(): ProjectRunner;
+    getModuleRunner?(): RunUI;
+    getModuleBuilder?(): ModuleAutoBuilder;
+}
+export {};

package/node_modules/@sap/artifact-management-base/dist/types/src/project/PluginEntryTypes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Depending on the DetectionMechanism the priority of the plugin execution will be determined.
+ */
+export declare enum DetectionMechanism {
+    /** Uniquely identified */
+    UNIQUE_IDENTIFICATION = "UNIQUE_IDENTIFICATION",
+    /** Identified by searching for file pattern */
+    FILE_PATTERN = "FILE_PATTERN",
+    /** Fallback, no specific detection */
+    FALLBACK = "FALLBACK",
+    /** Ignored for detection */
+    IGNORE = "IGNORE"
+}
+export declare const DetectionOrder: DetectionMechanism[];
+export declare function getDetectionPriority(mechanism: DetectionMechanism): number;

package/node_modules/@sap/artifact-management-base/dist/types/src/project/Project.d.ts

@@ -0,0 +1,5 @@
+import Module from './Module';
+import ProjectData from './ProjectData';
+export default interface Project extends ProjectData {
+    modules: Module[];
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ProjectData.d.ts

@@ -0,0 +1,39 @@
+import { StateMessage } from '../commons/StateMessage';
+export default interface ProjectData {
+    /**
+     * Project type
+     */
+    type: string;
+    /**
+     * Display name
+     */
+    name: string;
+    /**
+     * Project path
+     */
+    path: string;
+    /**
+     * Technical id for the service used as prefix for all cloud artifacts created for the project
+     *
+     * @todo: This should be moved to "project properties" later
+     */
+    prefix: string;
+    /**
+     * Namespace for the service used for the registration in BTP services such as HTML5 App Repo
+     *
+     * @todo: This should be moved to "project properties" later
+     */
+    cloudService: string;
+    /**
+     * Project version
+     */
+    version: string;
+    /**
+     * Tags related to the Project
+     */
+    tags: string[];
+    /**
+     * Info messages
+     */
+    info?: StateMessage[];
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ProjectManifestGenerator.d.ts

@@ -0,0 +1,28 @@
+import { Service } from '../cp/Service';
+import ModuleManifestGenerator from './ModuleManifestGenerator';
+import { ProjectType } from '../definitions/ProjectType';
+import { ModuleGeneratorContext } from './ModuleGeneratorContext';
+import { KeyIn } from '../util/Types';
+export declare type Mta = {
+    '_schema-version': string;
+    ID: string;
+    version: string;
+    description?: string;
+    parameters?: {
+        'enable-parallel-deployments'?: boolean;
+    };
+    'build-parameters'?: {
+        'before-all'?: {
+            builder: string;
+            commands: string[];
+        }[];
+    };
+    modules: any;
+    resources: any;
+};
+export default interface ProjectManifestGenerator {
+    getType: () => KeyIn<typeof ProjectType>;
+    provideResources: (context: ModuleGeneratorContext) => Service[];
+    getProjectManifest: (context: ModuleGeneratorContext) => Promise<Mta>;
+    getModuleGenerators: (context: ModuleGeneratorContext) => ModuleManifestGenerator[];
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ProjectReader.d.ts

@@ -0,0 +1,29 @@
+import { KeyIn } from '../util/Types';
+import ProjectEntityReader, { ProjectEntityMatchConditions, ProjectEntityReaderReadOptions } from '../project-api/ProjectEntityReader';
+import { ProjectType } from '../definitions/ProjectType';
+import { ModuleReader } from './ModuleReader';
+import { DetectionMechanism } from './PluginEntryTypes';
+import ProjectData from './ProjectData';
+export declare type ProjectReaderOptions = ProjectEntityReaderReadOptions;
+export declare abstract class ProjectReader implements ProjectEntityReader<ProjectData> {
+    readonly matchConditions: ProjectEntityMatchConditions;
+    static readonly type = "sap.project.plugin.type.project-reader";
+    projectType: string | undefined;
+    tags: string[];
+    /**
+     * Additional module readers that relate to parts of the project that are not represented by a standalone module.
+     * For each entry the first matching reader will be used similar like the directory matching works.
+     * The readers will be called for the project directory.
+     */
+    additionalModuleReaders: ModuleReader[][];
+    constructor(matchConditions: ProjectEntityMatchConditions);
+    abstract getType(): KeyIn<typeof ProjectType>;
+    abstract getDetectionMechanism(): DetectionMechanism;
+    read(options: ProjectReaderOptions): Promise<ProjectData | undefined>;
+    /**
+     * Return patterns to search for module directories
+     *
+     * @param options
+     */
+    moduleSearchPattern(): Promise<string[]>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ProjectReaderHelper.d.ts

@@ -0,0 +1,10 @@
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+import { NodePackage } from './NodePackage';
+declare class ProjectReaderHelper {
+    fs: ProjectFileSystem;
+    constructor(fs: ProjectFileSystem);
+    hasNodePackage(): Promise<boolean>;
+    readPackageJson(): Promise<NodePackage>;
+    hasPackageDependency(name: string): Promise<boolean>;
+}
+export { ProjectReaderHelper };

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ProjectRunner.d.ts

@@ -0,0 +1,14 @@
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+import { KeyIn } from '../util/Types';
+import { ProjectType } from '../definitions/ProjectType';
+import Project from './Project';
+export declare type RunOptions = {
+    fs: ProjectFileSystem;
+    project: Project;
+    options: string[] | undefined;
+};
+export default class ProjectRunner {
+    static type: string;
+    getType(): KeyIn<typeof ProjectType>;
+    run(options: RunOptions): Promise<void>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/ProjectWrapper.d.ts

@@ -0,0 +1,14 @@
+import { KeyIn } from '../util/Types';
+import { ProjectType } from '../definitions/ProjectType';
+import { ModuleReader } from './ModuleReader';
+import { DetectionMechanism } from './PluginEntryTypes';
+import ProjectData from './ProjectData';
+import { ProjectReader, ProjectReaderOptions } from './ProjectReader';
+export default class ProjectWrapper extends ProjectReader {
+    private moduleReader;
+    constructor(moduleReader: ModuleReader);
+    getType(): KeyIn<typeof ProjectType>;
+    getDetectionMechanism(): DetectionMechanism;
+    tags: string[];
+    read({ fs }: ProjectReaderOptions): Promise<ProjectData | undefined>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/TemplateInfo.d.ts

@@ -0,0 +1,6 @@
+export default interface TemplateInfo {
+    /** Id */
+    id: string;
+    /** Version  */
+    version: string;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project/UI5ModuleManifestGenerator.d.ts

@@ -0,0 +1,6 @@
+import { ModuleGeneratorContext } from './ModuleGeneratorContext';
+import ModuleManifestGenerator from './ModuleManifestGenerator';
+import { XSAppJson } from './Plugin';
+export default interface UI5ModuleManifestGenerator extends ModuleManifestGenerator {
+    getXSAppJson: (context: ModuleGeneratorContext) => XSAppJson;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project-api/FileSystemWatchManager.d.ts

@@ -0,0 +1,26 @@
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+export declare type ChangeListener = (event: string, file: string) => any;
+export declare type ChangeSetListener = (events: string[], files: string[]) => any;
+export declare enum EventType {
+    ADD = "add",
+    DELETE = "delete",
+    CHANGED = "changed",
+    DELETE_DIR = "unlinkDir",
+    ADD_DIR = "addDir"
+}
+export interface Observer {
+    fs: ProjectFileSystem;
+    basePath: string;
+    pathRelativeToRoot: string;
+    glob: string;
+    isGlob: boolean;
+    globPattern: string;
+    listener: ChangeListener;
+}
+export interface FileSystemWatchManager {
+    createFileSystemWatcher(fs: ProjectFileSystem, globPatterns: string[], onChange: ChangeListener): Observer[];
+    removeFileSystemWatcher(observers: Observer[]): void;
+    destroy(): void;
+    on(event: 'change', listener: ChangeSetListener): void;
+    removeListener(event: 'change', listener: ChangeSetListener): void;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project-api/ItemFilterImpl.d.ts

@@ -0,0 +1,13 @@
+import ItemFilter from '../project/ItemFilter';
+import Item from '../project/Item';
+import ItemFilterInterface from './ItemFilterInterface';
+declare function matchAlways(value: string): boolean;
+declare function matchAlwaysArray(values: string[]): boolean;
+export default class ItemFilterImpl implements ItemFilterInterface {
+    matchTags: typeof matchAlwaysArray;
+    matchType: typeof matchAlways;
+    matchRef: typeof matchAlways;
+    constructor(filter: ItemFilter);
+    match(entity: Item): boolean;
+}
+export {};

package/node_modules/@sap/artifact-management-base/dist/types/src/project-api/ItemFilterInterface.d.ts

@@ -0,0 +1,4 @@
+import Item from '../project/Item';
+export default interface ItemFilterInterface {
+    match(entity: Item): Boolean;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project-api/ItemFilterMatchAlwaysImpl.d.ts

@@ -0,0 +1,5 @@
+import Item from '../project/Item';
+import ItemFilterInterface from './ItemFilterInterface';
+export default class ItemFilterMatchAlwaysImpl implements ItemFilterInterface {
+    match(entity: Item): boolean;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/project-api/ProjectEntityReader.d.ts

@@ -0,0 +1,40 @@
+import ProjectFileSystem from '../commons/ProjectFileSystem';
+/**
+ * Conditions to match a reader
+ */
+export interface ProjectEntityMatchConditions {
+    /** At least one file per pattern must exists to call the reader. The files will be used as input. */
+    requiredFilePatterns?: string[];
+    /** If any file exists that match the pattern, the reader will not be called */
+    mustNotExistFilePatterns?: string[];
+    /** Files matching the pattern will be used as input for the reader. */
+    filePatterns?: string[];
+    /** Files matching the pattern influence the reader, but will not provided as input. */
+    dependentPatterns?: string[];
+    /** Function to additionally match conditions. Returns true if valid, else false */
+    rule?: (context: {
+        matchType: 'required' | 'mustNotExist';
+        fs: ProjectFileSystem;
+    }) => Promise<boolean>;
+}
+export declare type MatchedFiles = {
+    [pattern: string]: string[];
+};
+export interface ProjectEntityReaderReadOptions {
+    fs: ProjectFileSystem;
+    matchedFiles: MatchedFiles;
+}
+export default interface ProjectEntityReader<T> {
+    matchConditions: ProjectEntityMatchConditions;
+    tags: string[];
+    /**
+     * Read entity
+     *
+     * Match conditions are checked beforehand
+     *
+     * @param options
+     * @returns Entity data or undefined if entity doesn't match
+     *
+     */
+    read(options: ProjectEntityReaderReadOptions): Promise<T | undefined>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/util/NPMUtil.d.ts

@@ -0,0 +1,10 @@
+declare class NPMUtilClass {
+    private globalRootPathCache?;
+    private cdsPathCached?;
+    globalRootPath(): Promise<string | undefined>;
+    getCDSPath(): Promise<string | undefined>;
+    globalModulePath(name: string): Promise<string | undefined>;
+    assertCdsMinVersion(cds: any): boolean;
+}
+declare const NPMUtil: NPMUtilClass;
+export default NPMUtil;

package/node_modules/@sap/artifact-management-base/dist/types/src/util/TestUtil.d.ts

@@ -0,0 +1,3 @@
+export default class TestUtil {
+    static testName(filename: string): string;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/util/Types.d.ts

@@ -0,0 +1 @@
+export declare type KeyIn<T> = T[keyof T];

package/node_modules/@sap/artifact-management-base/dist/types/src/util/Util.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { SpawnOptions } from 'child_process';
+export declare type ExecResult = {
+    stdout?: string;
+    stderr?: string;
+};
+export default class Util {
+    static exec(command: string, ...args: string[]): Promise<ExecResult>;
+    static exec(options: SpawnOptions, command: string, ...args: string[]): Promise<ExecResult>;
+    static commandLineExecutor(command: any): Promise<any>;
+}

package/node_modules/@sap/artifact-management-base/dist/types/src/util/makeType.d.ts

@@ -0,0 +1,6 @@
+declare type Type<T> = {
+    new (...args: any): T;
+    type: string;
+};
+export default function makeType<T>(type: string): Type<T>;
+export {};