diff --git a/plugins/catalog-graphql/codegen.yml b/plugins/catalog-graphql/codegen.yml
index a4f3abcbe4..bb50b68101 100644
--- a/plugins/catalog-graphql/codegen.yml
+++ b/plugins/catalog-graphql/codegen.yml
@@ -1,9 +1,7 @@
 overwrite: true
-schema: ./schema.gql
-require:
-  - ts-node/register/transpile-only
 generates:
   ./src/graphql/types.ts:
+    schema: ./src/schema.js
     plugins:
       - typescript
       - typescript-resolvers
@@ -11,6 +9,7 @@ generates:
       afterOneFileWrite:
         - eslint --fix
     config:
-      contextType: '@graphql-modules/core#ModuleContext'
+      contextType: "@graphql-modules/core#ModuleContext"
+      allowParentTypeOverride: true
       useIndexSignature: true
       defaultMapper: Partial<{T}>
diff --git a/plugins/catalog-graphql/package.json b/plugins/catalog-graphql/package.json
index 28e72cefd3..83e88e1d25 100644
--- a/plugins/catalog-graphql/package.json
+++ b/plugins/catalog-graphql/package.json
@@ -27,7 +27,9 @@
     "@graphql-codegen/typescript": "^1.17.7",
     "@graphql-codegen/typescript-resolvers": "^1.17.7",
     "@graphql-modules/core": "^0.7.17",
+    "apollo-server": "^2.16.1",
     "graphql": "^15.3.0",
+    "graphql-tag": "^2.11.0",
     "graphql-type-json": "^0.3.2",
     "node-fetch": "^2.6.0",
     "ts-node": "^8.10.2",
diff --git a/plugins/catalog-graphql/schema.gql b/plugins/catalog-graphql/schema.gql
deleted file mode 100644
index 813b2840a6..0000000000
--- a/plugins/catalog-graphql/schema.gql
+++ /dev/null
@@ -1,62 +0,0 @@
-scalar JSON
-scalar JSONObject
-
-interface EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-}
-
-type ComponentMetadata implements EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-  relationships: String!
-}
-
-type TemplateMetadata implements EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-  updatedBy: String!
-}
-
-type DefaultEntityMetadata implements EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-}
-
-type CatalogEntity {
-  apiVersion: String!
-  kind: String!
-  metadata: EntityMetadata!
-}
-
-type CatalogQuery {
-  list: [CatalogEntity!]!
-}
-
-type Query {
-  catalog: CatalogQuery!
-}
diff --git a/plugins/catalog-graphql/src/graphql/module.ts b/plugins/catalog-graphql/src/graphql/module.ts
index f66ff5073e..c2266001b9 100644
--- a/plugins/catalog-graphql/src/graphql/module.ts
+++ b/plugins/catalog-graphql/src/graphql/module.ts
@@ -15,47 +15,23 @@
  */
 
 import { Logger } from 'winston';
-import fs from 'fs';
-import path from 'path';
 import { makeExecutableSchema } from 'apollo-server';
 import { GraphQLModule } from '@graphql-modules/core';
-import {
-  Resolvers,
-  CatalogQuery,
-  CatalogEntityTypes,
-  EntityMetadataResolvers,
-} from './types';
+import { Resolvers, CatalogQuery } from './types';
 import { Config } from '@backstage/config';
 import { CatalogClient } from '../service/client';
 import GraphQLJSON, { GraphQLJSONObject } from 'graphql-type-json';
+import { Entity } from '@backstage/catalog-model';
 
 export interface ModuleOptions {
   logger: Logger;
   config: Config;
 }
 
-const schemaPath = path.resolve(
-  require.resolve('@backstage/plugin-catalog-graphql/package.json'),
-  '../schema.gql',
-);
-
-const getSpecTypenameForEntity = (e: { kind?: string }) => {
-  switch (e.kind) {
-    case 'Component':
-      return 'ComponentEntity';
-    case 'Location':
-      return 'LocationEntity';
-    case 'Template':
-      return 'TemplateEntity';
-    default:
-      return null;
-  }
-};
-
 export async function createModule(
   options: ModuleOptions,
 ): Promise<GraphQLModule> {
-  const typeDefs = await fs.promises.readFile(schemaPath, 'utf-8');
+  const typeDefs = require('../schema');
 
   const catalogClient = new CatalogClient(
     options.config.getString('backend.baseUrl'),
@@ -64,6 +40,12 @@ export async function createModule(
   const resolvers: Resolvers = {
     JSON: GraphQLJSON,
     JSONObject: GraphQLJSONObject,
+    DefaultEntitySpec: {
+      raw: rootValue => {
+        const { entity } = rootValue as { entity: Entity };
+        return entity.spec ?? null;
+      },
+    },
     Query: {
       catalog: () => ({} as CatalogQuery),
     },
@@ -72,18 +54,15 @@ export async function createModule(
         return await catalogClient.list();
       },
     },
-    ComponentMetadata: {
-      relationships: () => 'boop',
-    },
-    TemplateMetadata: {
-      updatedBy: () => 'blam',
-    },
     CatalogEntity: {
-      metadata: e => ({ ...e.metadata!, catalogEntity: e }),
+      metadata: entity => ({ ...entity.metadata!, entity }),
+      spec: entity => ({ ...entity.spec!, entity }),
     },
     EntityMetadata: {
-      __resolveType: (obj: any) => {
-        const kind = obj.catalogEntity!.kind;
+      __resolveType: rootValue => {
+        const {
+          entity: { kind },
+        } = rootValue as { entity: Entity };
         switch (kind) {
           case 'Component':
             return 'ComponentMetadata';
@@ -94,23 +73,35 @@ export async function createModule(
         }
       },
       annotation: (e, { name }) => e.annotations?.[name] ?? null,
-      labels: e => e ?? {},
-      annotations: e => e ?? {},
+      labels: e => e.labels ?? {},
+      annotations: e => e.annotations ?? {},
       label: (e, { name }) => e.labels?.[name] ?? null,
     },
+    EntitySpec: {
+      __resolveType: rootValue => {
+        const {
+          entity: { kind },
+        } = rootValue as { entity: Entity };
+
+        switch (kind) {
+          case 'Component':
+            return 'ComponentEntitySpec';
+          case 'Template':
+            return 'TemplateEntitySpec';
+          default:
+            return 'DefaultEntitySpec';
+        }
+      },
+    },
   };
 
   const schema = makeExecutableSchema({
     typeDefs,
     resolvers,
     inheritResolversFromInterfaces: true,
-    resolverValidationOptions: {
-      allowResolversNotInSchema: true,
-    },
   });
 
   const module = new GraphQLModule({
-    resolverValidationOptions: {},
     extraSchemas: [schema],
     logger: options.logger as any,
   });
diff --git a/plugins/catalog-graphql/src/graphql/types.ts b/plugins/catalog-graphql/src/graphql/types.ts
index e2b10ec6a2..446a1f9f46 100644
--- a/plugins/catalog-graphql/src/graphql/types.ts
+++ b/plugins/catalog-graphql/src/graphql/types.ts
@@ -13,12 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+import {
+  GraphQLResolveInfo,
+  GraphQLScalarType,
+  GraphQLScalarTypeConfig,
+} from 'graphql';
 import { ModuleContext } from '@graphql-modules/core';
 
 export type Maybe<T> = T | null;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
-export type RequireFields<T, K extends keyof T> = { [X in Exclude<keyof T, K>]?: T[X] } & { [P in K]-?: NonNullable<T[P]> };
+export type Exact<T extends { [key: string]: unknown }> = {
+  [K in keyof T]: T[K];
+};
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type RequireFields<T, K extends keyof T> = {
+  [X in Exclude<keyof T, K>]?: T[X];
+} &
+  { [P in K]-?: NonNullable<T[P]> };
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
   ID: string;
@@ -30,8 +40,6 @@ export type Scalars = {
   JSONObject: any;
 };
 
-
-
 export type EntityMetadata = {
   name: Scalars['String'];
   annotations: Scalars['JSONObject'];
@@ -43,26 +51,14 @@ export type EntityMetadata = {
   generation: Scalars['Int'];
 };
 
-
 export type EntityMetadataAnnotationArgs = {
   name: Scalars['String'];
 };
 
-
 export type EntityMetadataLabelArgs = {
   name: Scalars['String'];
 };
 
-export type ComponentMetadata = EntityMetadata & {
-  __typename?: 'ComponentMetadata';
-  relationships: Scalars['String'];
-};
-
-export type TemplateMetadata = EntityMetadata & {
-  __typename?: 'TemplateMetadata';
-  updatedBy: Scalars['String'];
-};
-
 export type DefaultEntityMetadata = EntityMetadata & {
   __typename?: 'DefaultEntityMetadata';
   name: Scalars['String'];
@@ -73,24 +69,97 @@ export type DefaultEntityMetadata = EntityMetadata & {
   uid: Scalars['String'];
   etag: Scalars['String'];
   generation: Scalars['Int'];
-  updatedBy: Scalars['String'];
 };
 
-
 export type DefaultEntityMetadataAnnotationArgs = {
   name: Scalars['String'];
 };
 
-
 export type DefaultEntityMetadataLabelArgs = {
   name: Scalars['String'];
 };
 
+export type ComponentMetadata = EntityMetadata & {
+  __typename?: 'ComponentMetadata';
+  name: Scalars['String'];
+  annotations: Scalars['JSONObject'];
+  annotation?: Maybe<Scalars['JSON']>;
+  labels: Scalars['JSONObject'];
+  label?: Maybe<Scalars['JSON']>;
+  uid: Scalars['String'];
+  etag: Scalars['String'];
+  generation: Scalars['Int'];
+  relationships?: Maybe<Scalars['String']>;
+};
+
+export type ComponentMetadataAnnotationArgs = {
+  name: Scalars['String'];
+};
+
+export type ComponentMetadataLabelArgs = {
+  name: Scalars['String'];
+};
+
+export type TemplateMetadata = EntityMetadata & {
+  __typename?: 'TemplateMetadata';
+  name: Scalars['String'];
+  annotations: Scalars['JSONObject'];
+  annotation?: Maybe<Scalars['JSON']>;
+  labels: Scalars['JSONObject'];
+  label?: Maybe<Scalars['JSON']>;
+  uid: Scalars['String'];
+  etag: Scalars['String'];
+  generation: Scalars['Int'];
+  updatedBy?: Maybe<Scalars['String']>;
+};
+
+export type TemplateMetadataAnnotationArgs = {
+  name: Scalars['String'];
+};
+
+export type TemplateMetadataLabelArgs = {
+  name: Scalars['String'];
+};
+
+export type TemplateEntitySpec = {
+  __typename?: 'TemplateEntitySpec';
+  type: Scalars['String'];
+  path?: Maybe<Scalars['String']>;
+  schema: Scalars['JSONObject'];
+  templater: Scalars['String'];
+};
+
+export type ComponentEntitySpec = {
+  __typename?: 'ComponentEntitySpec';
+  title: Scalars['String'];
+  lifecycle: Scalars['String'];
+  owner: Scalars['String'];
+};
+
+export type LocationEntitySpec = {
+  __typename?: 'LocationEntitySpec';
+  type: Scalars['String'];
+  target?: Maybe<Scalars['String']>;
+  targets: Array<Scalars['String']>;
+};
+
+export type DefaultEntitySpec = {
+  __typename?: 'DefaultEntitySpec';
+  raw?: Maybe<Scalars['JSONObject']>;
+};
+
+export type EntitySpec =
+  | DefaultEntitySpec
+  | TemplateEntitySpec
+  | LocationEntitySpec
+  | ComponentEntitySpec;
+
 export type CatalogEntity = {
   __typename?: 'CatalogEntity';
   apiVersion: Scalars['String'];
   kind: Scalars['String'];
-  metadata: EntityMetadata;
+  metadata?: Maybe<EntityMetadata>;
+  spec: EntitySpec;
 };
 
 export type CatalogQuery = {
@@ -108,7 +177,6 @@ export type ResolversObject<TObject> = WithIndex<TObject>;
 
 export type ResolverTypeWrapper<T> = Promise<T> | T;
 
-
 export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
   fragment: string;
   resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
@@ -118,7 +186,9 @@ export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
   selectionSet: string;
   resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
 };
-export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
+export type StitchingResolver<TResult, TParent, TContext, TArgs> =
+  | LegacyStitchingResolver<TResult, TParent, TContext, TArgs>
+  | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
 export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
   | ResolverFn<TResult, TParent, TContext, TArgs>
   | StitchingResolver<TResult, TParent, TContext, TArgs>;
@@ -127,26 +197,42 @@ export type ResolverFn<TResult, TParent, TContext, TArgs> = (
   parent: TParent,
   args: TArgs,
   context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => Promise<TResult> | TResult;
 
 export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
   parent: TParent,
   args: TArgs,
   context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;
 
 export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
   parent: TParent,
   args: TArgs,
   context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>;
 
-export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
-  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
-  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+export interface SubscriptionSubscriberObject<
+  TResult,
+  TKey extends string,
+  TParent,
+  TContext,
+  TArgs
+> {
+  subscribe: SubscriptionSubscribeFn<
+    { [key in TKey]: TResult },
+    TParent,
+    TContext,
+    TArgs
+  >;
+  resolve?: SubscriptionResolveFn<
+    TResult,
+    { [key in TKey]: TResult },
+    TContext,
+    TArgs
+  >;
 }
 
 export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
@@ -154,43 +240,82 @@ export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
   resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
 }
 
-export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
+export type SubscriptionObject<
+  TResult,
+  TKey extends string,
+  TParent,
+  TContext,
+  TArgs
+> =
   | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
   | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
 
-export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+export type SubscriptionResolver<
+  TResult,
+  TKey extends string,
+  TParent = {},
+  TContext = {},
+  TArgs = {}
+> =
+  | ((
+      ...args: any[]
+    ) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
   | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
 
 export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
   parent: TParent,
   context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
 
-export type IsTypeOfResolverFn<T = {}> = (obj: T, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export type IsTypeOfResolverFn<T = {}> = (
+  obj: T,
+  info: GraphQLResolveInfo,
+) => boolean | Promise<boolean>;
 
 export type NextResolverFn<T> = () => Promise<T>;
 
-export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+export type DirectiveResolverFn<
+  TResult = {},
+  TParent = {},
+  TContext = {},
+  TArgs = {}
+> = (
   next: NextResolverFn<TResult>,
   parent: TParent,
   args: TArgs,
   context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>;
 
 /** Mapping between all available schema types and the resolvers types */
 export type ResolversTypes = ResolversObject<{
   JSON: ResolverTypeWrapper<Partial<Scalars['JSON']>>;
   JSONObject: ResolverTypeWrapper<Partial<Scalars['JSONObject']>>;
-  EntityMetadata: ResolversTypes['ComponentMetadata'] | ResolversTypes['TemplateMetadata'] | ResolversTypes['DefaultEntityMetadata'];
+  EntityMetadata:
+    | ResolversTypes['DefaultEntityMetadata']
+    | ResolversTypes['ComponentMetadata']
+    | ResolversTypes['TemplateMetadata'];
   String: ResolverTypeWrapper<Partial<Scalars['String']>>;
   Int: ResolverTypeWrapper<Partial<Scalars['Int']>>;
+  DefaultEntityMetadata: ResolverTypeWrapper<Partial<DefaultEntityMetadata>>;
   ComponentMetadata: ResolverTypeWrapper<Partial<ComponentMetadata>>;
   TemplateMetadata: ResolverTypeWrapper<Partial<TemplateMetadata>>;
-  DefaultEntityMetadata: ResolverTypeWrapper<Partial<DefaultEntityMetadata>>;
-  CatalogEntity: ResolverTypeWrapper<Partial<CatalogEntity>>;
+  TemplateEntitySpec: ResolverTypeWrapper<Partial<TemplateEntitySpec>>;
+  ComponentEntitySpec: ResolverTypeWrapper<Partial<ComponentEntitySpec>>;
+  LocationEntitySpec: ResolverTypeWrapper<Partial<LocationEntitySpec>>;
+  DefaultEntitySpec: ResolverTypeWrapper<Partial<DefaultEntitySpec>>;
+  EntitySpec: Partial<
+    | ResolversTypes['DefaultEntitySpec']
+    | ResolversTypes['TemplateEntitySpec']
+    | ResolversTypes['LocationEntitySpec']
+    | ResolversTypes['ComponentEntitySpec']
+  >;
+  CatalogEntity: ResolverTypeWrapper<
+    Partial<
+      Omit<CatalogEntity, 'spec'> & { spec: ResolversTypes['EntitySpec'] }
+    >
+  >;
   CatalogQuery: ResolverTypeWrapper<Partial<CatalogQuery>>;
   Query: ResolverTypeWrapper<{}>;
   Boolean: ResolverTypeWrapper<Partial<Scalars['Boolean']>>;
@@ -200,74 +325,241 @@ export type ResolversTypes = ResolversObject<{
 export type ResolversParentTypes = ResolversObject<{
   JSON: Partial<Scalars['JSON']>;
   JSONObject: Partial<Scalars['JSONObject']>;
-  EntityMetadata: ResolversParentTypes['ComponentMetadata'] | ResolversParentTypes['TemplateMetadata'] | ResolversParentTypes['DefaultEntityMetadata'];
+  EntityMetadata:
+    | ResolversParentTypes['DefaultEntityMetadata']
+    | ResolversParentTypes['ComponentMetadata']
+    | ResolversParentTypes['TemplateMetadata'];
   String: Partial<Scalars['String']>;
   Int: Partial<Scalars['Int']>;
+  DefaultEntityMetadata: Partial<DefaultEntityMetadata>;
   ComponentMetadata: Partial<ComponentMetadata>;
   TemplateMetadata: Partial<TemplateMetadata>;
-  DefaultEntityMetadata: Partial<DefaultEntityMetadata>;
-  CatalogEntity: Partial<CatalogEntity>;
+  TemplateEntitySpec: Partial<TemplateEntitySpec>;
+  ComponentEntitySpec: Partial<ComponentEntitySpec>;
+  LocationEntitySpec: Partial<LocationEntitySpec>;
+  DefaultEntitySpec: Partial<DefaultEntitySpec>;
+  EntitySpec: Partial<
+    | ResolversParentTypes['DefaultEntitySpec']
+    | ResolversParentTypes['TemplateEntitySpec']
+    | ResolversParentTypes['LocationEntitySpec']
+    | ResolversParentTypes['ComponentEntitySpec']
+  >;
+  CatalogEntity: Partial<
+    Omit<CatalogEntity, 'spec'> & { spec: ResolversParentTypes['EntitySpec'] }
+  >;
   CatalogQuery: Partial<CatalogQuery>;
   Query: {};
   Boolean: Partial<Scalars['Boolean']>;
 }>;
 
-export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['JSON'], any> {
+export interface JsonScalarConfig
+  extends GraphQLScalarTypeConfig<ResolversTypes['JSON'], any> {
   name: 'JSON';
 }
 
-export interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['JSONObject'], any> {
+export interface JsonObjectScalarConfig
+  extends GraphQLScalarTypeConfig<ResolversTypes['JSONObject'], any> {
   name: 'JSONObject';
 }
 
-export type EntityMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['EntityMetadata'] = ResolversParentTypes['EntityMetadata']> = ResolversObject<{
-  __resolveType: TypeResolveFn<'ComponentMetadata' | 'TemplateMetadata' | 'DefaultEntityMetadata', ParentType, ContextType>;
+export type EntityMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['EntityMetadata']
+> = ResolversObject<{
+  __resolveType: TypeResolveFn<
+    'DefaultEntityMetadata' | 'ComponentMetadata' | 'TemplateMetadata',
+    ParentType,
+    ContextType
+  >;
   name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  annotation?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<EntityMetadataAnnotationArgs, 'name'>>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<EntityMetadataAnnotationArgs, 'name'>
+  >;
   labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  label?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<EntityMetadataLabelArgs, 'name'>>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<EntityMetadataLabelArgs, 'name'>
+  >;
   uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
 }>;
 
-export type ComponentMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['ComponentMetadata'] = ResolversParentTypes['ComponentMetadata']> = ResolversObject<{
-  relationships?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
-}>;
-
-export type TemplateMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['TemplateMetadata'] = ResolversParentTypes['TemplateMetadata']> = ResolversObject<{
-  updatedBy?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
-}>;
-
-export type DefaultEntityMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['DefaultEntityMetadata'] = ResolversParentTypes['DefaultEntityMetadata']> = ResolversObject<{
+export type DefaultEntityMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['DefaultEntityMetadata']
+> = ResolversObject<{
   name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  annotation?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<DefaultEntityMetadataAnnotationArgs, 'name'>>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<DefaultEntityMetadataAnnotationArgs, 'name'>
+  >;
   labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  label?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<DefaultEntityMetadataLabelArgs, 'name'>>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<DefaultEntityMetadataLabelArgs, 'name'>
+  >;
   uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
-  updatedBy?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   __isTypeOf?: IsTypeOfResolverFn<ParentType>;
 }>;
 
-export type CatalogEntityResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['CatalogEntity'] = ResolversParentTypes['CatalogEntity']> = ResolversObject<{
+export type ComponentMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['ComponentMetadata']
+> = ResolversObject<{
+  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<ComponentMetadataAnnotationArgs, 'name'>
+  >;
+  labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<ComponentMetadataLabelArgs, 'name'>
+  >;
+  uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  relationships?: Resolver<
+    Maybe<ResolversTypes['String']>,
+    ParentType,
+    ContextType
+  >;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type TemplateMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['TemplateMetadata']
+> = ResolversObject<{
+  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<TemplateMetadataAnnotationArgs, 'name'>
+  >;
+  labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<TemplateMetadataLabelArgs, 'name'>
+  >;
+  uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  updatedBy?: Resolver<
+    Maybe<ResolversTypes['String']>,
+    ParentType,
+    ContextType
+  >;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type TemplateEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['TemplateEntitySpec']
+> = ResolversObject<{
+  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  path?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  schema?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  templater?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type ComponentEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['ComponentEntitySpec']
+> = ResolversObject<{
+  title?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  lifecycle?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  owner?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type LocationEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['LocationEntitySpec']
+> = ResolversObject<{
+  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  target?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  targets?: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type DefaultEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['DefaultEntitySpec']
+> = ResolversObject<{
+  raw?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type EntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['EntitySpec']
+> = ResolversObject<{
+  __resolveType: TypeResolveFn<
+    | 'DefaultEntitySpec'
+    | 'TemplateEntitySpec'
+    | 'LocationEntitySpec'
+    | 'ComponentEntitySpec',
+    ParentType,
+    ContextType
+  >;
+}>;
+
+export type CatalogEntityResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['CatalogEntity']
+> = ResolversObject<{
   apiVersion?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   kind?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  metadata?: Resolver<ResolversTypes['EntityMetadata'], ParentType, ContextType>;
+  metadata?: Resolver<
+    Maybe<ResolversTypes['EntityMetadata']>,
+    ParentType,
+    ContextType
+  >;
+  spec?: Resolver<ResolversTypes['EntitySpec'], ParentType, ContextType>;
   __isTypeOf?: IsTypeOfResolverFn<ParentType>;
 }>;
 
-export type CatalogQueryResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['CatalogQuery'] = ResolversParentTypes['CatalogQuery']> = ResolversObject<{
-  list?: Resolver<Array<ResolversTypes['CatalogEntity']>, ParentType, ContextType>;
+export type CatalogQueryResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['CatalogQuery']
+> = ResolversObject<{
+  list?: Resolver<
+    Array<ResolversTypes['CatalogEntity']>,
+    ParentType,
+    ContextType
+  >;
   __isTypeOf?: IsTypeOfResolverFn<ParentType>;
 }>;
 
-export type QueryResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
+export type QueryResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['Query']
+> = ResolversObject<{
   catalog?: Resolver<ResolversTypes['CatalogQuery'], ParentType, ContextType>;
 }>;
 
@@ -275,15 +567,19 @@ export type Resolvers<ContextType = ModuleContext> = ResolversObject<{
   JSON?: GraphQLScalarType;
   JSONObject?: GraphQLScalarType;
   EntityMetadata?: EntityMetadataResolvers<ContextType>;
+  DefaultEntityMetadata?: DefaultEntityMetadataResolvers<ContextType>;
   ComponentMetadata?: ComponentMetadataResolvers<ContextType>;
   TemplateMetadata?: TemplateMetadataResolvers<ContextType>;
-  DefaultEntityMetadata?: DefaultEntityMetadataResolvers<ContextType>;
+  TemplateEntitySpec?: TemplateEntitySpecResolvers<ContextType>;
+  ComponentEntitySpec?: ComponentEntitySpecResolvers<ContextType>;
+  LocationEntitySpec?: LocationEntitySpecResolvers<ContextType>;
+  DefaultEntitySpec?: DefaultEntitySpecResolvers<ContextType>;
+  EntitySpec?: EntitySpecResolvers<ContextType>;
   CatalogEntity?: CatalogEntityResolvers<ContextType>;
   CatalogQuery?: CatalogQueryResolvers<ContextType>;
   Query?: QueryResolvers<ContextType>;
 }>;
 
-
 /**
  * @deprecated
  * Use "Resolvers" root object instead. If you wish to get "IResolvers", add "typesPrefix: I" to your config.