angular-odata 0.127.0 → 0.128.0

package/lib/schema/element.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationConfig } from '../types';
+import { AnnotationConfig, Parser } from '../types';
 import { ODataAnnotatable } from './annotation';
 import { ODataSchema } from './schema';
 export declare class ODataSchemaElement extends ODataAnnotatable {
@@ -29,17 +29,24 @@ export declare class ODataSchemaElement extends ODataAnnotatable {
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
-    isTypeOf(type: string): boolean;
+    isTypeOf(element: ODataSchemaElement): boolean;
     /**
      * Returns a boolean indicating if the structured type is a subtype of the given type.
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
-    isSubtypeOf(schema: ODataSchemaElement): boolean;
+    isSubtypeOf(element: ODataSchemaElement): boolean;
     /**
      * Returns a boolean indicating if the structured type is a supertype of the given type.
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
-    isSupertypeOf(schema: ODataSchemaElement): boolean;
+    isSupertypeOf(element: ODataSchemaElement): boolean;
+}
+export declare class ODataParserSchemaElement<E, P extends Parser<E>> extends ODataSchemaElement {
+    parser: P;
+    constructor(config: {
+        annotations?: AnnotationConfig[];
+        name: string;
+    }, schema: ODataSchema, parser: P);
 }

package/lib/schema/entity-container.d.ts

@@ -2,7 +2,9 @@ import { EntityContainerConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataEntitySet } from './entity-set';
 import { ODataSchema } from './schema';
+import { ODataSingleton } from './singleton';
 export declare class ODataEntityContainer extends ODataSchemaElement {
     entitySets: ODataEntitySet[];
+    singletons: ODataSingleton[];
     constructor(config: EntityContainerConfig, schema: ODataSchema);
 }

package/lib/schema/enum-type.d.ts

@@ -1,19 +1,16 @@
-import { EnumTypeConfig, Parser, ParserOptions } from '../types';
-import { ODataSchemaElement } from './element';
+import { EnumTypeConfig, ParserOptions } from '../types';
+import { ODataParserSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 import { ODataSchema } from './schema';
-export declare class ODataEnumType<E> extends ODataSchemaElement {
-    parser: ODataEnumTypeParser<E>;
+export declare class ODataEnumType<E> extends ODataParserSchemaElement<E, ODataEnumTypeParser<E>> {
     members: {
         [name: string]: E;
     } | {
         [value: number]: string;
     };
     constructor(config: EnumTypeConfig<E>, schema: ODataSchema);
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options }: {
         options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
     /**
      * Returns the fields of the enum type.

package/lib/schema/index.d.ts

@@ -4,4 +4,5 @@ export * from './callable';
 export * from './enum-type';
 export * from './structured-type';
 export * from './entity-set';
+export * from './singleton';
 export * from './parsers';

package/lib/schema/parsers/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, ParserOptions, Parameter, Parser } from '../../types';
+import { CallableConfig, ParserOptions, ParameterConfig, Parser } from '../../types';
 import { ODataEnumTypeParser } from './enum-type';
 import { ODataStructuredTypeParser } from './structured-type';
 export declare class ODataParameterParser<T> {
@@ -8,19 +8,18 @@ export declare class ODataParameterParser<T> {
     collection?: boolean;
     nullable?: boolean;
     parserOptions?: ParserOptions;
-    constructor(name: string, parameter: Parameter);
+    constructor(name: string, parameter: ParameterConfig);
     serialize(value: T, options?: ParserOptions): any;
     encode(value: any, options?: ParserOptions): string;
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options, parserForType, }: {
         options: ParserOptions;
         parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
     isEdmType(): boolean;
     isEnumType(): boolean;
-    enum(): ODataEnumTypeParser<T>;
+    enumType(): ODataEnumTypeParser<T>;
     isStructuredType(): boolean;
-    structured(): ODataStructuredTypeParser<T>;
+    structuredType(): ODataStructuredTypeParser<T>;
     field<F>(name: string): import("./structured-type").ODataStructuredTypeFieldParser<F>;
 }
 export declare class ODataCallableParser<R> implements Parser<R> {
@@ -39,10 +38,10 @@ export declare class ODataCallableParser<R> implements Parser<R> {
     deserialize(value: any, options?: ParserOptions): R;
     serialize(params: any, options?: ParserOptions): any;
     encode(params: any, options?: ParserOptions): any;
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options, parserForType, }: {
         options: ParserOptions;
         parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
     binding(): ODataParameterParser<any> | undefined;
+    returnType(): string | undefined;
 }

package/lib/schema/parsers/enum-type.d.ts

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, EnumTypeFieldConfig, ParserOptions, Parser, FieldParser, JsonType } from '../../types';
+import { EnumTypeConfig, EnumTypeFieldConfig, ParserOptions, FieldParser, JsonType } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 export declare class ODataEnumTypeFieldParser<E> extends ODataAnnotatable {
     name: string;
@@ -19,10 +19,8 @@ export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements
     private _fields;
     parserOptions?: ParserOptions;
     constructor(config: EnumTypeConfig<E>, namespace: string, alias?: string);
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options }: {
         options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
     isTypeOf(type: string): boolean;
     fields(value?: E): ODataEnumTypeFieldParser<E>[];

package/lib/schema/parsers/structured-type.d.ts

@@ -35,7 +35,7 @@ export declare class ODataReferential {
 }
 export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable implements FieldParser<T> {
     name: string;
-    private structuredType;
+    private structured;
     type: string | EdmType;
     private parser;
     collection: boolean;
@@ -47,7 +47,7 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
     scale?: number | 'variable';
     referentials: ODataReferential[];
     parserOptions?: ParserOptions;
-    constructor(name: string, structuredType: ODataStructuredTypeParser<any>, field: StructuredTypeFieldConfig);
+    constructor(name: string, structured: ODataStructuredTypeParser<any>, field: StructuredTypeFieldConfig);
     validate(value: any, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
@@ -61,19 +61,18 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
     private toJson;
     serialize(value: T, options?: ParserOptions): any;
     encode(value: T, options?: ParserOptions): string;
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options, parserForType, }: {
         options: ParserOptions;
         parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
     toJsonSchema(options?: JsonSchemaOptions<T>): any;
     isKey(): boolean;
     hasReferentials(): boolean;
     isEdmType(): boolean;
     isEnumType(): boolean;
-    enum(): ODataEnumTypeParser<T>;
+    enumType(): ODataEnumTypeParser<T>;
     isStructuredType(): boolean;
-    structured(): ODataStructuredTypeParser<T>;
+    structuredType(): ODataStructuredTypeParser<T>;
     field<F>(name: string): ODataStructuredTypeFieldParser<F>;
 }
 export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable implements Parser<T> {
@@ -105,10 +104,9 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     deserialize(value: any, options?: ParserOptions): T;
     serialize(value: Partial<T>, options?: ParserOptions): any;
     encode(value: T, options?: ParserOptions): any;
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options, parserForType, }: {
         options: ParserOptions;
         parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
     /**
      * Returns all fields of the structured type.

package/lib/schema/schema.d.ts

@@ -1,10 +1,11 @@
 import { ODataApi } from '../api';
-import { Parser, ParserOptions, SchemaConfig } from '../types';
+import { ParserOptions, SchemaConfig, StructuredTypeConfig } from '../types';
 import { ODataAnnotatable } from './annotation';
 import { ODataCallable } from './callable';
 import { ODataEntityContainer } from './entity-container';
 import { ODataEntitySet } from './entity-set';
 import { ODataEnumType } from './enum-type';
+import { ODataSingleton } from './singleton';
 import { ODataStructuredType } from './structured-type';
 export declare class ODataSchema extends ODataAnnotatable {
     api: ODataApi;
@@ -15,15 +16,11 @@ export declare class ODataSchema extends ODataAnnotatable {
     callables: ODataCallable<any>[];
     containers: ODataEntityContainer[];
     constructor(config: SchemaConfig, api: ODataApi);
-    isNamespaceOf(type: string): boolean | "" | undefined;
+    isNamespaceOf(type: string): boolean;
     get entitySets(): ODataEntitySet[];
-    findEnumTypeForType<T>(type: string): ODataEnumType<T> | undefined;
-    findStructuredTypeForType<T>(type: string): ODataStructuredType<T> | undefined;
-    findCallableForType<T>(type: string, bindingType?: string): ODataCallable<T> | undefined;
-    findEntitySetForType(type: string): ODataEntitySet | undefined;
-    configure({ options, parserForType, findOptionsForType, }: {
+    get singletons(): ODataSingleton[];
+    createStructuredType<T>(config: StructuredTypeConfig<T>): ODataStructuredType<T>;
+    configure({ options }: {
         options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
 }

package/lib/schema/singleton.d.ts

@@ -0,0 +1,10 @@
+import { SingletonConfig } from '../types';
+import { ODataSchemaElement } from './element';
+import { ODataSchema } from './schema';
+export declare class ODataSingleton extends ODataSchemaElement {
+    singletonType: string;
+    service: {
+        new (...params: any[]): any;
+    };
+    constructor(config: SingletonConfig, schema: ODataSchema);
+}

package/lib/schema/structured-type.d.ts

@@ -1,21 +1,18 @@
-import { ODataCollection } from '../models';
+import { ODataCollection } from '../models/collection';
 import { ODataModel } from '../models/model';
-import { Parser, ParserOptions, StructuredTypeConfig, StructuredTypeFieldConfig } from '../types';
-import { ODataSchemaElement } from './element';
+import { ParserOptions, StructuredTypeConfig, StructuredTypeFieldConfig } from '../types';
+import { ODataParserSchemaElement } from './element';
 import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
-export declare class ODataStructuredType<T> extends ODataSchemaElement {
+export declare class ODataStructuredType<T> extends ODataParserSchemaElement<T, ODataStructuredTypeParser<T>> {
     base?: string;
     parent?: ODataStructuredType<any>;
     children: ODataStructuredType<any>[];
     model?: typeof ODataModel;
     collection?: typeof ODataCollection;
-    parser: ODataStructuredTypeParser<T>;
     constructor(config: StructuredTypeConfig<T>, schema: ODataSchema);
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options }: {
         options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => any;
     }): void;
     /**
      * Returns a boolean indicating if the structured type is a subtype of the given type.

package/lib/services/entity-set.d.ts

@@ -4,6 +4,10 @@ import { ODataModel } from '../models/model';
 import { EntityKey, ODataEntity, ODataEntityResource, ODataEntitySetResource, ODataOptions } from '../resources';
 import { ODataEntityService } from './entity';
 export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
+    static Model?: typeof ODataModel;
+    static Collection?: typeof ODataCollection;
+    model(entity?: Partial<T>): ODataModel<T>;
+    collection(entities?: Partial<T>[]): ODataCollection<T, ODataModel<T>>;
     /**
      * Get the entity set resource for this service.
      */
@@ -29,7 +33,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      */
     fetchAll(options?: ODataOptions): Observable<{
         entities: T[];
-        annots: import("../resources").ODataEntitiesAnnotations<T>;
+        annots: import("../annotations").ODataEntitiesAnnotations<T>;
     }>;
     /**
      * Get entities from the entity set.
@@ -40,7 +44,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
         withCount?: boolean;
     }): Observable<{
         entities: T[];
-        annots: import("../resources").ODataEntitiesAnnotations<T>;
+        annots: import("../annotations").ODataEntitiesAnnotations<T>;
     }>;
     /**
      * Get an entity from the entity set.
@@ -52,7 +56,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
         etag?: string;
     }): Observable<{
         entity: T | null;
-        annots: import("../resources").ODataEntitiesAnnotations<T>;
+        annots: import("../annotations").ODataEntitiesAnnotations<T>;
     }>;
     /**
      * Create an entity in the entity set.

package/lib/services/factory.d.ts

@@ -1,6 +1,7 @@
 import { ODataClient } from '../client';
 import { ODataEntitySetService } from './entity-set';
 import { ODataSingletonService } from './singleton';
+import { ODataCollection, ODataModel } from '../models';
 import * as i0 from "@angular/core";
 export declare class ODataServiceFactory {
     protected client: ODataClient;
@@ -10,12 +11,23 @@ export declare class ODataServiceFactory {
      * @param entitySetName Name of the entity set.
      * @param apiNameOrEntityType Name of the API or the type of the entity.
      */
-    entitySet<T>(entitySetName: string, apiNameOrEntityType?: string): ODataEntitySetService<T>;
+    entitySet<T>(entitySetName: string, apiNameOrEntityType?: string, options?: {
+        Model?: {
+            new (...params: any[]): ODataModel<T>;
+        };
+        Collection?: {
+            new (...params: any[]): ODataCollection<T, ODataModel<T>>;
+        };
+    }): ODataEntitySetService<T>;
     /** Factory method to create a singleton service.
      * @param singletonName Name of the singleton.
      * @param apiNameOrEntityType Name of the API or the type of the entity.
      */
-    singleton<T>(singletonName: string, apiNameOrEntityType?: string): ODataSingletonService<T>;
+    singleton<T>(singletonName: string, apiNameOrEntityType?: string, options?: {
+        Model?: {
+            new (...params: any[]): ODataModel<T>;
+        };
+    }): ODataSingletonService<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ODataServiceFactory, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ODataServiceFactory>;
 }

package/lib/services/singleton.d.ts

@@ -1,12 +1,14 @@
 import { Observable } from 'rxjs';
-import type { ODataModel } from '../models/model';
-import type { ODataEntity, ODataOptions, ODataSingletonResource } from '../resources';
+import { ODataModel } from '../models/model';
+import { ODataEntity, ODataOptions, ODataSingletonResource } from '../resources';
 import { ODataEntityService } from './entity';
 /**
  * OData Singleton Service
  * www.odata.org/getting-started/advanced-tutorial/#singleton
  */
 export declare class ODataSingletonService<T> extends ODataEntityService<T> {
+    static Model?: typeof ODataModel;
+    model(entity?: Partial<T>): ODataModel<T>;
     /**
      * Get the entity resource for this service.
      * @param key The entity key.

package/lib/settings.d.ts

@@ -3,7 +3,6 @@ import { ODataApi } from './api';
 import { ODataCollection, ODataModel } from './models';
 import { ODataRequest } from './resources';
 import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
-import { ODataEntityService } from './services/entity';
 import { ApiConfig, EdmType, Parser } from './types';
 export declare class ODataSettings {
     apis: ODataApi[];
@@ -24,13 +23,4 @@ export declare class ODataSettings {
     parserForType<T>(type: string | EdmType): Parser<T>;
     modelForType(type: string): typeof ODataModel;
     collectionForType(type: string): typeof ODataCollection;
-    serviceForType(type: string): typeof ODataEntityService;
-    serviceForEntityType(type: string): typeof ODataEntityService;
-    enumTypeByName<T>(name: string): ODataEnumType<T>;
-    structuredTypeByName<T>(name: string): ODataStructuredType<T>;
-    callableByName<T>(name: string, bindingType?: string): ODataCallable<T>;
-    entitySetByName(name: string): ODataEntitySet;
-    modelByName(name: string): typeof ODataModel;
-    collectionByName(name: string): typeof ODataCollection;
-    serviceByName(name: string): typeof ODataEntityService;
 }

package/lib/types.d.ts

@@ -180,6 +180,7 @@ export type EntityContainerConfig = {
     name: string;
     annotations?: AnnotationConfig[];
     entitySets?: EntitySetConfig[];
+    singletons?: SingletonConfig[];
 };
 export type EnumTypeFieldConfig<E> = {
     value: E;
@@ -231,11 +232,11 @@ export type StructuredTypeConfig<T> = {
         name: string;
         alias?: string;
     }[];
-    fields: {
+    fields?: {
         [P in keyof T]?: StructuredTypeFieldConfig;
     };
 };
-export type Parameter = {
+export type ParameterConfig = {
     type: string;
     nullable?: boolean;
     collection?: boolean;
@@ -246,7 +247,7 @@ export type CallableConfig = {
     bound?: boolean;
     composable?: boolean;
     parameters?: {
-        [name: string]: Parameter;
+        [name: string]: ParameterConfig;
     };
     return?: {
         type: string;
@@ -261,3 +262,11 @@ export type EntitySetConfig = {
     };
     annotations?: AnnotationConfig[];
 };
+export type SingletonConfig = {
+    name: string;
+    type: string;
+    service: {
+        new (...params: any[]): any;
+    };
+    annotations?: AnnotationConfig[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.127.0",
+  "version": "0.128.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {
@@ -28,6 +28,10 @@
     "@angular/common": ">=14.0.0",
     "@angular/core": ">=14.0.0"
   },
+  "schematics": "./schematics/collection.json",
+  "ng-add": {
+    "save": "dependencies"
+  },
   "dependencies": {
     "tslib": "^2.3.0"
   },

package/schematics/apigen/angular/api-config.d.ts

@@ -0,0 +1,15 @@
+import { Base } from './base';
+import { Source } from '@angular-devkit/schematics';
+import { Schema as ApiGenSchema } from '../schema';
+export declare class ApiConfig extends Base {
+    constructor(options: ApiGenSchema);
+    template(): Source;
+    variables(): {
+        [name: string]: any;
+    };
+    name(): string;
+    fileName(): string;
+    directory(): string;
+    fullName(): string;
+    importTypes(): string[];
+}

package/schematics/apigen/angular/api-config.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConfig = void 0;
+const core_1 = require("@angular-devkit/core");
+const base_1 = require("./base");
+const schematics_1 = require("@angular-devkit/schematics");
+class ApiConfig extends base_1.Base {
+    constructor(options) {
+        super(options);
+    }
+    template() {
+        return (0, schematics_1.url)('./files/api-config');
+    }
+    variables() {
+        return Object.assign({}, this.options);
+    }
+    name() {
+        return core_1.strings.classify(this.options.name) + 'Config';
+    }
+    fileName() {
+        return core_1.strings.dasherize(this.options.name) + '.config';
+    }
+    directory() {
+        return '';
+    }
+    fullName() {
+        return this.name();
+    }
+    importTypes() {
+        return [];
+    }
+}
+exports.ApiConfig = ApiConfig;
+//# sourceMappingURL=api-config.js.map

package/schematics/apigen/angular/api-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-config.js","sourceRoot":"","sources":["../../../../../projects/angular-odata/schematics/apigen/angular/api-config.ts"],"names":[],"mappings":";;;AAAA,+CAA+C;AAC/C,iCAA8B;AAC9B,2DAAyD;AAGzD,MAAa,SAAU,SAAQ,WAAI;IACjC,YAAY,OAAqB;QAC/B,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IACe,QAAQ;QACtB,OAAO,IAAA,gBAAG,EAAC,oBAAoB,CAAC,CAAC;IACnC,CAAC;IACe,SAAS;QACvB,yBAAY,IAAI,CAAC,OAAO,EAAG;IAC7B,CAAC;IACe,IAAI;QAClB,OAAO,cAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;IACxD,CAAC;IACe,QAAQ;QACtB,OAAO,cAAO,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAC1D,CAAC;IACe,SAAS;QACvB,OAAO,EAAE,CAAC;IACZ,CAAC;IACe,QAAQ;QACtB,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IACe,WAAW;QACzB,OAAO,EAAE,CAAC;IACZ,CAAC;CACF;AAzBD,8BAyBC"}

package/schematics/apigen/angular/base.d.ts

@@ -0,0 +1,51 @@
+import { Import } from './import';
+import { Source } from '@angular-devkit/schematics';
+import { Schema as ApiGenSchema } from '../schema';
+import { CsdlCallable, CsdlParameter } from '../metadata/csdl/csdl-function-action';
+export declare class Callable {
+    protected callable: CsdlCallable;
+    constructor(callable: CsdlCallable);
+    name(): string;
+    isBound(): boolean | undefined;
+    bindingParameter(): CsdlParameter | undefined;
+    parameters(): CsdlParameter[];
+    returnType(): import("../metadata/csdl/csdl-function-action").CsdlReturnType | undefined;
+    fullName(): string;
+    resourceFunction(): string;
+    callableFunction(): string;
+}
+export declare abstract class Base {
+    protected options: ApiGenSchema;
+    constructor(options: ApiGenSchema);
+    abstract name(): string;
+    abstract fileName(): string;
+    abstract fullName(): string;
+    abstract directory(): string;
+    abstract importTypes(): string[];
+    abstract template(): Source;
+    abstract variables(): {
+        [name: string]: any;
+    };
+    path(): string;
+    imports(): Import[];
+    importedName?: string;
+    cleanImportedNames(): void;
+    protected dependencies: [string, Base][];
+    addDependency(renderable: Base): void;
+    addDependencies(renderables: Base[]): void;
+    protected callables: Callable[];
+    addCallable(callable: Callable): void;
+    addCallables(callables: Callable[]): void;
+}
+export declare class Index extends Base {
+    constructor(options: ApiGenSchema);
+    template(): Source;
+    variables(): {
+        [name: string]: any;
+    };
+    name(): string;
+    fileName(): string;
+    directory(): string;
+    fullName(): string;
+    importTypes(): string[];
+}