@sprucelabs/spruce-templates 22.1.13 → 22.3.0

package/build/dist/templates/typescript/schema/valueTypes.ts.hbs

@@ -0,0 +1,67 @@
+import { FieldDefinitions } from '#spruce/schemas/fields/fields.types'
+
+import fieldClassMap from '#spruce/schemas/fields/fieldClassMap'
+import { TemplateRenderAs, FieldTemplateDetailOptions } from '@sprucelabs/schema'
+
+
+{{#each imports}}
+// @ts-ignore
+import * as {{importAs}} from '{{package}}'
+{{/each}}
+
+const schemaTemplateItems = {{{json schemaTemplateItems}}}
+// @ts-ignore
+const generateTypeLiteral = (definition: FieldDefinitions, renderAs: TemplateRenderAs, importAs: string) => {
+	const options: FieldTemplateDetailOptions<FieldDefinitions> = {
+		language: 'ts',
+		// @ts-ignore
+		templateItems: schemaTemplateItems,
+		globalNamespace: '{{globalSchemaNamespace}}',
+		definition,
+		importAs,
+		renderAs
+	}
+
+	const FieldClass = fieldClassMap[definition.type]
+	const details = FieldClass.generateTemplateDetails(
+		options as any
+	)
+	
+	return details.valueType
+}
+
+
+const valueTypes = {
+	{{#each schemaTemplatesByNamespaceAndName}}
+	"{{@key}}": {
+		{{#each this}}
+		"{{@key}}": {
+			{{#each this}} 
+			"{{schema.version}}{{#unless schema.version}}{{../../../SCHEMA_VERSION_FALLBACK}}{{/unless}}":{
+				{{#if schema.dynamicFieldSignature}}
+				__dynamicFieldSignature: {
+					valueTypes: {
+						{{#each ../../../rendersAs}}
+						{{this}}: {{{ valueTypeGenerator ../schema.dynamicFieldSignature this 'generateTypeLiteral'}}},
+						{{/each}}
+					}
+				},	
+				{{/if}}
+				{{#each schema.fields}}
+				"{{@key}}": {
+					valueTypes: {
+						{{#each ../../../../rendersAs}}
+						{{this}}: {{{ valueTypeGenerator ../this this 'generateTypeLiteral'}}},
+						{{/each}}
+					}
+				},
+				{{/each}}
+			},
+			{{/each}}
+		},
+		{{/each}}
+	},
+	{{/each}}
+}
+
+export default valueTypes

package/build/dist/templates/typescript/store/Store.store.ts.hbs

@@ -0,0 +1,95 @@
+import { AbstractStore, UniversalStoreOptions, PrepareOptions, PrepareResults } from '@sprucelabs/data-stores'
+import { buildSchema, dropFields, makeFieldsOptional, SchemaValues, SchemaFieldNames } from '@sprucelabs/schema'
+
+export default class {{namePascalPlural}}Store extends AbstractStore<
+	FullSchema, 
+	CreateSchema, 
+	UpdateSchema, 
+	DatabaseSchema 
+> {
+	public name = '{{namePascalPlural}}'
+	protected collectionName = '{{nameSnakePlural}}'
+
+	protected createSchema = createSchema
+	protected updateSchema = updateSchema
+	protected fullSchema = fullSchema
+	protected databaseSchema = databaseSchema
+
+	public static Store(options: {{namePascal}}StoreOptions & UniversalStoreOptions) {
+		return new this(options.db)
+	}
+
+	protected async willCreate(
+		values: Create{{namePascal}}
+	): Promise<Omit<Database{{namePascal}}, 'id'>> {
+		return values
+	}
+
+	protected async willUpdate(values: Update{{namePascal}}) {
+		return values as Partial<Database{{namePascal}}>
+	}
+
+	
+	protected async prepareRecord<
+		IncludePrivateFields extends boolean,
+		F extends SchemaFieldNames<FullSchema> = SchemaFieldNames<FullSchema>
+	>(
+		record: Database{{namePascal}},
+		_options?: PrepareOptions<IncludePrivateFields, FullSchema, F>
+	) {
+		return record as PrepareResults<FullSchema, IncludePrivateFields>
+	}
+
+}
+
+// The structure of the data you'll be returning from finds
+const fullSchema = buildSchema({
+	id: 'full{{namePascal}}',
+	fields: {
+        id: {
+            type: 'id',
+			isRequired: true,
+        }
+    },
+})
+
+// The values you will accept when creating a record
+const createSchema = buildSchema({
+	id: 'create{{namePascal}}',
+	fields: {
+        ...dropFields(fullSchema.fields, ['id'])
+    },
+})
+
+// The values you will accept when updating a record
+const updateSchema = buildSchema({
+	id: 'update{{namePascal}}',
+	fields: {
+        ...makeFieldsOptional(dropFields(fullSchema.fields, ['id']))
+    },
+})
+
+// The values you will actually save to the databases (in this case, makes id required)
+const databaseSchema = buildSchema({
+	id: 'database{{namePascal}}',
+	fields: {
+        ...fullSchema.fields,
+		 id: {
+            type: 'id',
+			isRequired: true
+        }
+    },
+})
+
+type FullSchema = typeof fullSchema
+type CreateSchema = typeof createSchema
+type UpdateSchema = typeof updateSchema
+type DatabaseSchema = typeof databaseSchema
+
+// type {{namePascal}} = SchemaValues<FullSchema>
+type Create{{namePascal}} = SchemaValues<CreateSchema>
+type Update{{namePascal}} = SchemaValues<UpdateSchema>
+type Database{{namePascal}} = SchemaValues<DatabaseSchema>
+// type Query{{namePascal}} = Partial<{{namePascal}}>
+
+type {{namePascal}}StoreOptions = UniversalStoreOptions

package/build/dist/templates/typescript/store/store.plugin.ts.hbs

@@ -0,0 +1 @@
+export { plugin as default } from '@sprucelabs/spruce-store-plugin'

package/build/dist/templates/typescript/store/stores.ts.hbs

@@ -0,0 +1,9 @@
+{{#each stores}}
+import {{namePascalPlural}}Store from '{{path}}'
+{{/each}}
+
+export default {
+    {{#each stores}}
+            {{nameCamelPlural}}: {{namePascalPlural}}Store,
+    {{/each}}
+}

package/build/dist/templates/typescript/store/stores.types.ts.hbs

@@ -0,0 +1,17 @@
+{{#each stores}}
+import {{namePascalPlural}}Store from '{{path}}'
+{{/each}}
+
+declare module '@sprucelabs/data-stores/build/types/stores.types' {
+	interface StoreMap {
+        {{#each stores}}
+                {{nameCamelPlural}}: {{namePascalPlural}}Store
+        {{/each}}
+	}
+
+	interface StoreOptionsMap {
+        {{#each stores}}
+                {{nameCamelPlural}}: Omit<Parameters<typeof {{namePascalPlural}}Store['Store']>[0], keyof UniversalStoreOptions>   
+        {{/each}}
+        }
+}

package/build/dist/templates/typescript/test/Test.test.ts.hbs

@@ -0,0 +1,20 @@
+{{#if isTestFixturesInstalled}}import { fake } from '@sprucelabs/spruce-test-fixtures'{{/if}}
+import {{#unless (isDefined parentTestClass)}}AbstractSpruceTest, {{/unless}}{ test, assert } from '@sprucelabs/test-utils'
+{{#if (isDefined parentTestClass)}}import {{#if parentTestClass.isDefaultExport}}{{parentTestClass.name}}{{else}}{ {{parentTestClass.name}} }{{/if}} from '{{parentTestClass.importPath}}'
+{{/if}}
+
+{{#if isTestFixturesInstalled}}@fake.login(){{/if}}
+export default class {{namePascal}}Test extends {{#if (isDefined parentTestClass)}}{{parentTestClass.name}}{{else}}AbstractSpruceTest{{/if}} {
+	@test()
+	protected static async canCreate{{namePascal}}() {
+		const {{nameCamel}} = new {{namePascal}}()
+		assert.isTruthy({{nameCamel}})
+	}
+
+	@test()
+	protected static async yourNextTest() {
+		assert.isTrue(false)
+	}
+}
+
+class {{namePascal}} {}

package/build/dist/templates/typescript/view/App.avc.ts.hbs

@@ -0,0 +1,5 @@
+import { AbstractAppViewController, AppViewControllerLoadOptions } from '@sprucelabs/heartwood-view-controllers'
+
+export default class AppViewControllerImpl extends AbstractAppViewController {
+    public async (_options: AppViewControllerLoadOptions) {}
+}

package/build/dist/templates/typescript/view/View.svc.ts.hbs

@@ -0,0 +1,23 @@
+import {
+	AbstractSkillViewController,
+	ViewControllerOptions,
+	SkillView,
+} from '@sprucelabs/heartwood-view-controllers'
+
+export default class {{namePascal}}SkillViewController extends AbstractSkillViewController {
+	public static id = '{{nameKebab}}'
+
+	public constructor(options: ViewControllerOptions) {
+		super(options)
+	}
+
+	public render(): SkillView {
+		return {
+			layouts: [
+				{
+					cards: [],
+				},
+			],
+		}
+	}
+}

package/build/dist/templates/typescript/view/View.vc.ts.hbs

@@ -0,0 +1,17 @@
+import {
+	AbstractViewController,
+	ViewControllerOptions,
+	{{viewModel}},
+} from '@sprucelabs/heartwood-view-controllers'
+
+export default class {{namePascal}}ViewController extends AbstractViewController<{{viewModel}}> {
+	public static id = '{{nameKebab}}'
+
+	public constructor(options: ViewControllerOptions) {
+		super(options)
+	}
+	
+	public render() {
+		return {}
+	}
+}

package/build/dist/templates/typescript/view/skill.theme.ts.hbs

@@ -0,0 +1,70 @@
+import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas'
+import '#spruce/schemas/schemas.types'
+
+// The Theme Skill (https://theme.spruce.bot/) is available to help you build your theme!
+
+const theme: SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ThemeProps = {
+	/**
+	 ************************************
+	 * Background
+	 ************************************
+	 */
+	color1: '#ffffff',
+	color1Inverse: '#0f4c8a',
+	color1InverseGradient: 'linear-gradient(to left, #24c6dc, #514a9d)',
+	
+	/**
+	 ************************************
+	 * Cards
+	 ************************************
+	 */
+	color2: 'black',
+	color2Transparent: 'rgba(0,0,0,0.4)',
+	color2Inverse: 'white',
+	color2InverseTransparent: 'rgba(255,255,255,0.9)',
+
+	/**
+	 ************************************
+	 * Headers
+	 ************************************
+	 */
+	color3: 'grey',
+	color3Inverse: 'transparent',
+	color3Compliment: 'grey',
+
+	/**
+	 ************************************
+	 * Buttons
+	 ************************************
+	 */
+	color4: '#3a3a3a',
+	color4Inverse: '#DCE0E7',
+	color4Compliment: '#DCE0E4',
+	color4ComplimentTransparent: 'rgba(0,0,0,0.2)',
+	color4InverseCompliment: '#c7c7c7',
+
+	/**
+	 ************************************
+	 * Control bar
+	 ************************************
+	 */
+	controlBarColor1: 'black',
+	controlBarColor2: 'white',
+
+	/**
+	 ************************************
+	 * Tool belt
+	 ************************************
+	 */
+	toolBeltColor2: 'white',
+
+	/**
+	 ************************************
+	 * Errors
+	 ************************************
+	 */
+	errorColor1: '#fff',
+	errorColor1Inverse: '#FF3326',
+}
+
+export default theme

package/build/dist/templates/typescript/view/view.plugin.ts.hbs

@@ -0,0 +1 @@
+export { plugin as default } from '@sprucelabs/spruce-view-plugin'

package/build/dist/templates/typescript/view/viewController.plugin.ts.hbs

@@ -0,0 +1,3 @@
+import { ViewControllerPlugin } from '@sprucelabs/heartwood-view-controllers'
+
+export default class {{namePascal}}ViewPlugin implements ViewControllerPlugin {}

package/build/dist/templates/typescript/view/views.ts.hbs

@@ -0,0 +1,78 @@
+{{#each svcTemplateItems}}
+import {{namePascal}} from '{{path}}'
+{{/each}}
+{{#each vcTemplateItems}}
+import {{namePascal}} from '{{path}}'
+{{/each}}
+{{#each viewPluginItems}}
+import {{namePascal}} from '{{path}}'
+{{/each}}
+
+import '@sprucelabs/heartwood-view-controllers'
+
+const vcs = {
+    {{#each svcTemplateItems}}
+    {{namePascal}},
+    {{/each}}
+    {{#each vcTemplateItems}}
+    {{namePascal}},
+    {{/each}}
+}
+
+export const pluginsByName = {
+	{{#each viewPluginItems}}
+	{{nameCamel}}: {{namePascal}},
+	{{/each}}
+}
+
+{{#if svcTemplateItems}}
+type LoadOptions<Args extends Record<string,any>[]> = Args[0]['args'] extends Record<string, any> ? Args[0]['args'] : Record<never, any>
+{{/if}}
+
+declare module '@sprucelabs/heartwood-view-controllers/build/types/heartwood.types' {
+	interface SkillViewControllerMap {
+        {{#each svcTemplateItems}}
+		'{{../namespaceKebab}}.{{id}}': {{namePascal}}
+        {{/each}}
+	}
+
+	interface SkillViewControllerArgsMap {
+        {{#each svcTemplateItems}}
+		'{{../namespaceKebab}}.{{id}}': LoadOptions<Parameters<{{namePascal}}['load']>>
+        {{/each}}
+	}
+
+	interface ViewControllerMap {
+        {{#each vcTemplateItems}}
+		'{{../namespaceKebab}}.{{id}}': {{namePascal}}
+        {{/each}}
+         {{#each svcTemplateItems}}
+		'{{../namespaceKebab}}.{{id}}': {{namePascal}}
+        {{/each}}
+	}
+
+    interface ViewControllerOptionsMap {
+		 {{#each vcTemplateItems}}
+		'{{../namespaceKebab}}.{{id}}': ConstructorParameters<typeof {{namePascal}}>[0]
+        {{/each}}
+	}
+
+	interface ViewControllerPlugins {
+		{{#each viewPluginItems}}
+		{{nameCamel}}: {{namePascal}}
+		{{/each}}
+	}
+}
+
+//@ts-ignore
+if(typeof heartwood === 'function') { 
+	{{#if appTemplateItem}}
+	//@ts-ignore
+	heartwood({ vcs, pluginsByName, App: {{appTemplateItem.namePascal}} }) 
+	{{else}}
+	//@ts-ignore
+	heartwood({ vcs, pluginsByName }) 
+	{{/if}}
+}
+
+export default vcs

package/build/esm/addons/eq.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/eq.addon.js

@@ -0,0 +1,4 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('eq', (num, min) => {
+    return num === min;
+});

package/build/esm/addons/escape.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/escape.addon.js

@@ -0,0 +1,5 @@
+import handlebars from 'handlebars';
+/* Escape quotes */
+handlebars.registerHelper('escape', function (variable) {
+    return variable && variable.replace && variable.replace(/(['])/g, '\\$1');
+});

package/build/esm/addons/fieldDefinitionBodyPartial.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/fieldDefinitionBodyPartial.addon.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import fs from 'fs-extra';
+import handlebars from 'handlebars';
+const templatePath = path.join(__dirname, '..', 'templates', 'typescript');
+const fieldPartial = fs
+    .readFileSync(path.join(templatePath, 'schema/partials/fieldDefinitionBody.ts.hbs'))
+    .toString();
+handlebars.registerPartial('fieldDefinitionBody', fieldPartial);

package/build/esm/addons/fieldDefinitionOptions.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/fieldDefinitionOptions.addon.js

@@ -0,0 +1,66 @@
+import { TemplateRenderAs } from '@sprucelabs/schema';
+import handlebars from 'handlebars';
+/** Renders field options */
+handlebars.registerHelper('fieldDefinitionOptions', function (namespace, schemaNameCamel, version, fieldName, fieldDefinition, renderAs, options) {
+    if (typeof namespace !== 'string') {
+        throw new Error('fieldDefinitionOptions helper needs namespace first');
+    }
+    if (typeof schemaNameCamel !== 'string') {
+        throw new Error('fieldDefinitionOptions helper needs schemaNameCamel 2nd.');
+    }
+    if (typeof fieldName !== 'string') {
+        throw new Error('fieldDefinitionOptions helper needs fieldName 3rd');
+    }
+    if (!fieldDefinition) {
+        throw new Error('fieldDefinitionOptions helper needs a FieldDefinition as the 4th argument');
+    }
+    if (!options ||
+        (renderAs !== TemplateRenderAs.Type &&
+            renderAs !== TemplateRenderAs.Value)) {
+        throw new Error("fieldDefinitionOptions helper's second arg as type|value");
+    }
+    const { data: { root }, } = options;
+    const schemaTemplateItems = root && root.schemaTemplateItems;
+    if (!schemaTemplateItems) {
+        throw new Error('fieldDefinitionOptions needs schemaTemplateItems passed to parent template');
+    }
+    const updatedOptions = fieldDefinition.options && Object.assign({}, fieldDefinition.options);
+    // If this is a schema type, we need to map it to it's proper value type
+    if (fieldDefinition.type === 'schema' && updatedOptions) {
+        const value = handlebars.helpers.valueTypeLiteral(namespace, schemaNameCamel, version, fieldName, renderAs === TemplateRenderAs.Type
+            ? TemplateRenderAs.SchemaType
+            : TemplateRenderAs.Value, options);
+        // Swap out id for reference
+        delete updatedOptions.schemaId;
+        delete updatedOptions.schema;
+        delete updatedOptions.schemaIds;
+        delete updatedOptions.schemas;
+        if (value.substr(-1) === ']') {
+            updatedOptions.schemas = value;
+        }
+        else {
+            updatedOptions.schema = value;
+        }
+    }
+    // No options, undefined is acceptable
+    if (Object.keys(updatedOptions !== null && updatedOptions !== void 0 ? updatedOptions : {}).length === 0) {
+        return 'undefined';
+    }
+    let template = `{`;
+    Object.keys(updatedOptions !== null && updatedOptions !== void 0 ? updatedOptions : {}).forEach((key) => {
+        // @ts-ignore TODO how to type this
+        const value = updatedOptions[key];
+        template += `${key}: `;
+        if (key === 'schemas' || key === 'schema') {
+            template += `${value},`;
+        }
+        else if (typeof value !== 'string') {
+            template += `${JSON.stringify(value)},`;
+        }
+        else {
+            template += `\`${value.replace(/([`])/g, '\\$1')}\`,`;
+        }
+    });
+    template += '}';
+    return template;
+});

package/build/esm/addons/fieldTypeEnum.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/fieldTypeEnum.addon.js

@@ -0,0 +1,9 @@
+import handlebars from 'handlebars';
+/* The enum for schema.fields.fieldName.type as a string */
+handlebars.registerHelper('fieldTypeEnum', function (fieldDefinitions) {
+    if (!fieldDefinitions) {
+        throw new Error('fieldTypeEnum helper needs a FieldDefinitions as the first argument');
+    }
+    const { type } = fieldDefinitions;
+    return `'${type}'`;
+});

package/build/esm/addons/fieldValue.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/fieldValue.addon.js

@@ -0,0 +1,8 @@
+import handlebars from 'handlebars';
+/** Drop in the value of a field which quotes if needed */
+handlebars.registerHelper('fieldValue', function (fieldDefinitions, value) {
+    if (value) {
+        throw new Error('field value not yet implemented');
+    }
+    return value;
+});

package/build/esm/addons/gt.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/gt.addon.js

@@ -0,0 +1,4 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('gt', (num, min) => {
+    return num > min;
+});

package/build/esm/addons/hasKeys.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/hasKeys.addon.js

@@ -0,0 +1,4 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('hasKeys', function (value) {
+    return typeof value === 'object' ? Object.keys(value).length > 0 : false;
+});

package/build/esm/addons/hasNoneCoreSchemaTemplateItems.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/hasNoneCoreSchemaTemplateItems.addon.js

@@ -0,0 +1,6 @@
+import { CORE_NAMESPACE } from '@sprucelabs/spruce-skill-utils';
+import handlebars from 'handlebars';
+handlebars.registerHelper('hasNonCoreSchemaTemplateItems', function (schemaTemplateItems) {
+    return (schemaTemplateItems.filter((i) => i.namespace !== CORE_NAMESPACE)
+        .length > 0);
+});

package/build/esm/addons/importRelatedSchemas.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/importRelatedSchemas.addon.js

@@ -0,0 +1,34 @@
+import { SchemaField } from '@sprucelabs/schema';
+import handlebars from 'handlebars';
+import { camelCase, uniq } from 'lodash';
+handlebars.registerHelper('importRelatedSchemas', function (schema, options) {
+    var _a;
+    if (!schema) {
+        throw new Error('importRelatedSchemas needs a Schema as the first arg');
+    }
+    const { data: { root }, } = options;
+    const schemaTemplateItems = root === null || root === void 0 ? void 0 : root.schemaTemplateItems;
+    if (!schemaTemplateItems) {
+        throw new Error('importRelatedSchemas needs schemaTemplateItems passed to parent template');
+    }
+    const fields = schema.dynamicFieldSignature
+        ? [schema.dynamicFieldSignature]
+        : Object.values((_a = schema.fields) !== null && _a !== void 0 ? _a : {});
+    const imports = [];
+    fields.forEach((field) => {
+        if (field.type === 'schema') {
+            const related = SchemaField.mapFieldDefinitionToSchemaIdsWithVersion(field);
+            related.forEach((idWithVersion) => {
+                const matched = schemaTemplateItems.find((t) => t.id === idWithVersion.id &&
+                    t.schema.version === idWithVersion.version &&
+                    t.schema.namespace === idWithVersion.namespace);
+                if (matched) {
+                    imports.push(`import ${matched.nameCamel}Schema${matched.schema.version
+                        ? `_${matched.schema.version}`
+                        : ''} from '${matched.destinationDir}/${camelCase(matched.namespace)}${matched.schema.version ? `/${matched.schema.version}` : ''}/${matched.id}.schema'`);
+                }
+            });
+        }
+    });
+    return uniq(imports).join('\n');
+});

package/build/esm/addons/index.d.ts

@@ -0,0 +1,23 @@
+import './eq.addon';
+import './escape.addon';
+import './fieldDefinitionBodyPartial.addon';
+import './fieldDefinitionOptions.addon';
+import './fieldTypeEnum.addon';
+import './fieldValue.addon';
+import './gt.addon';
+import './hasKeys.addon';
+import './hasNoneCoreSchemaTemplateItems.addon';
+import './importRelatedSchemas.addon';
+import './index';
+import './isDefined.addon';
+import './json.addon';
+import './neq.addon';
+import './operators.addon';
+import './pascalCase.addon';
+import './permissionContractBuilder.addon';
+import './schemaBodyPartial.addon';
+import './schemaNamespacePath.addon';
+import './schemaValuesPartial.addon';
+import './valueTypeGenerator.addon';
+import './valueTypeLiteral.addon';
+import './valueTypeMapper.addon';

package/build/esm/addons/index.js

@@ -0,0 +1,23 @@
+import './eq.addon';
+import './escape.addon';
+import './fieldDefinitionBodyPartial.addon';
+import './fieldDefinitionOptions.addon';
+import './fieldTypeEnum.addon';
+import './fieldValue.addon';
+import './gt.addon';
+import './hasKeys.addon';
+import './hasNoneCoreSchemaTemplateItems.addon';
+import './importRelatedSchemas.addon';
+import './index';
+import './isDefined.addon';
+import './json.addon';
+import './neq.addon';
+import './operators.addon';
+import './pascalCase.addon';
+import './permissionContractBuilder.addon';
+import './schemaBodyPartial.addon';
+import './schemaNamespacePath.addon';
+import './schemaValuesPartial.addon';
+import './valueTypeGenerator.addon';
+import './valueTypeLiteral.addon';
+import './valueTypeMapper.addon';