contentful-management 11.33.0 → 11.35.0

package/dist/es-modules/adapters/REST/endpoints/index.js

@@ -35,7 +35,9 @@ import * as AccessToken from './access-token';
 import * as PreviewApiKey from './preview-api-key';
 import * as Release from './release';
 import * as ReleaseAction from './release-action';
+import * as Resource from './resource';
 import * as ResourceProvider from './resource-provider';
+import * as ResourceType from './resource-type';
 import * as Role from './role';
 import * as ScheduledAction from './scheduled-action';
 import * as Snapshot from './snapshot';
@@ -94,7 +96,9 @@ export default {
   PreviewApiKey,
   Release,
   ReleaseAction,
+  Resource,
   ResourceProvider,
+  ResourceType,
   Role,
   ScheduledAction,
   Snapshot,

package/dist/es-modules/adapters/REST/endpoints/resource-type.js

@@ -0,0 +1,23 @@
+import * as raw from './raw';
+import copy from 'fast-copy';
+const getBaseUrl = params => `/organizations/${params.organizationId}/app_definitions/${params.appDefinitionId}/resource_provider/resource_types`;
+const getEntityUrl = params => `${getBaseUrl(params)}/${params.resourceTypeId}`;
+const getSpaceEnvUrl = params => `/spaces/${params.spaceId}/environments/${params.environmentId}/resource_types`;
+export const get = (http, params) => {
+  return raw.get(http, getEntityUrl(params));
+};
+export const upsert = (http, params, rawData, headers) => {
+  const data = copy(rawData);
+  return raw.put(http, getEntityUrl(params), data, {
+    headers
+  });
+};
+export const del = (http, params) => {
+  return raw.del(http, getEntityUrl(params));
+};
+export const getMany = (http, params) => {
+  return raw.get(http, getBaseUrl(params));
+};
+export const getForEnvironment = (http, params) => {
+  return raw.get(http, getSpaceEnvUrl(params));
+};

package/dist/es-modules/adapters/REST/endpoints/resource.js

@@ -0,0 +1,5 @@
+import * as raw from './raw';
+const getBaseUrl = params => `/spaces/${params.spaceId}/environments/${params.environmentId}/resource_types/${params.resourceTypeId}/resources`;
+export const getMany = (http, params) => raw.get(http, getBaseUrl(params), {
+  params: params.query
+});

package/dist/es-modules/contentful-management.js

@@ -46,7 +46,7 @@ function createClient(params, opts = {}) {
   const sdkMain = opts.type === 'plain' ? 'contentful-management-plain.js' : 'contentful-management.js';
   const userAgent = getUserAgentHeader(
   // @ts-expect-error
-  `${sdkMain}/${"11.33.0"}`, params.application, params.integration, params.feature);
+  `${sdkMain}/${"11.35.0"}`, params.application, params.integration, params.feature);
   const adapter = createAdapter(_objectSpread(_objectSpread({}, params), {}, {
     userAgent
   }));

package/dist/es-modules/create-environment-api.js

@@ -78,6 +78,12 @@ export default function createEnvironmentApi(makeRequest) {
   const {
     wrapAppAccessToken
   } = entities.appAccessToken;
+  const {
+    wrapResourceTypesForEnvironmentCollection
+  } = entities.resourceType;
+  const {
+    wrapResourceCollection
+  } = entities.resource;
   return {
     /**
      * Deletes the environment
@@ -2249,6 +2255,78 @@ export default function createEnvironmentApi(makeRequest) {
           environmentId: raw.sys.id
         })
       }).then(data => wrapEnvironmentTemplateInstallationCollection(makeRequest, data));
+    },
+    /**
+     * Gets a collection of all resource types based on native external references app installations in the environment
+     * @param query - BasicCursorPaginationOptions
+     * @return Promise for a collection of ResourceTypes
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getResourceTypes({limit: 10}))
+     * .then((installations) => console.log(installations.items))
+     * .catch(console.error)
+     * ```
+     */
+    async getResourceTypes(query) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'ResourceType',
+        action: 'getForEnvironment',
+        params: {
+          query,
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id
+        }
+      }).then(data => wrapResourceTypesForEnvironmentCollection(makeRequest, data));
+    },
+    /**
+     * Gets a collection of all resources for a given resource type based on native external references app installations in the environment
+     * @param resourceTypeId - Id of the resourceType to get its resources
+     * @param query - Either LookupQuery options with 'sys.urn[in]' param or a Search query with 'query' param, in both cases you can add pagination options
+     * @return Promise for a collection of Resources for a given resourceTypeId
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * // Search Query
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * // <search_query> is a string you want to search for in the external resources
+     * .then((environment) => environment.getResourcesForResourceType('<resource_type_id>', {query: '<search_query>', limit: 10}))
+     * .then((installations) => console.log(installations.items))
+     * .catch(console.error)
+     *
+     * // Lookup query
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getResourcesForResourceType('<resource_type_id>', {'sys.urn[in]': '<resource_urn1>,<resource_urn2>', limit: 10}))
+     * .then((installations) => console.log(installations.items))
+     * .catch(console.error)
+     * ```
+     */
+    async getResourcesForResourceType(resourceTypeId, query) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Resource',
+        action: 'getMany',
+        params: {
+          query,
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          resourceTypeId
+        }
+      }).then(data => wrapResourceCollection(makeRequest, data));
     }
   };
 }

package/dist/es-modules/entities/index.js

@@ -53,6 +53,8 @@ import * as workflowDefinition from './workflow-definition';
 import * as concept from './concept';
 import * as conceptScheme from './concept-scheme';
 import * as resourceProvider from './resource-provider';
+import * as resourceType from './resource-type';
+import * as resource from './resource';
 export default {
   accessToken,
   appAction,
@@ -91,6 +93,8 @@ export default {
   release,
   releaseAction,
   resourceProvider,
+  resourceType,
+  resource,
   role,
   scheduledAction,
   snapshot,

package/dist/es-modules/entities/resource-provider.js

@@ -1,10 +1,14 @@
 import { toPlainObject, freezeSys } from 'contentful-sdk-core';
 import copy from 'fast-copy';
 import enhanceWithMethods from '../enhance-with-methods';
+import entities from '.';
 /**
  * @private
  */
 function createResourceProviderApi(makeRequest) {
+  const {
+    wrapResourceType
+  } = entities.resourceType;
   return {
     /**
      * Sends an update to the server with any changes made to the object's properties
@@ -60,6 +64,43 @@ function createResourceProviderApi(makeRequest) {
         action: 'delete',
         params: getParams(data)
       });
+    },
+    getResourceType: function getResourceType(id) {
+      return makeRequest({
+        entityType: 'ResourceType',
+        action: 'get',
+        params: {
+          organizationId: this.sys.organization.sys.id,
+          appDefinitionId: this.sys.appDefinition.sys.id,
+          resourceTypeId: id
+        }
+      }).then(data => wrapResourceType(makeRequest, data));
+    },
+    upsertResourceType: function upsertResourceType(id, data) {
+      return makeRequest({
+        entityType: 'ResourceType',
+        action: 'upsert',
+        params: {
+          organizationId: this.sys.organization.sys.id,
+          appDefinitionId: this.sys.appDefinition.sys.id,
+          resourceTypeId: id
+        },
+        headers: {},
+        payload: data
+      }).then(data => wrapResourceType(makeRequest, data));
+    },
+    getResourceTypes: function getResourceTypes() {
+      return makeRequest({
+        entityType: 'ResourceType',
+        action: 'getMany',
+        params: {
+          organizationId: this.sys.organization.sys.id,
+          appDefinitionId: this.sys.appDefinition.sys.id
+        }
+      }).then(data => {
+        data.items = data.items.map(item => wrapResourceType(makeRequest, item));
+        return data;
+      });
     }
   };
 }

package/dist/es-modules/entities/resource-type.js

@@ -0,0 +1,93 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import enhanceWithMethods from '../enhance-with-methods';
+import { wrapCursorPaginatedCollection } from '../common-utils';
+const publicResourceTypeFields = ['name'];
+/**
+ * @private
+ */
+function createResourceTypeApi(makeRequest) {
+  return {
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('<org_id>')
+     * .then((org) => org.getAppDefinition('<app_def_id>'))
+     * .then((appDefinition) => appDefinition.getResourceType())
+     * .then((resourceType) => {
+     *    resourceType.name = '<new_name>'
+     *    return resourceType.upsert()
+     * })
+     * .catch(console.error)
+     * ```
+     */
+    upsert: function upsert() {
+      const data = this.toPlainObject();
+      return makeRequest({
+        entityType: 'ResourceType',
+        action: 'upsert',
+        params: getParams(data),
+        headers: {},
+        payload: getUpsertParams(data)
+      }).then(data => wrapResourceType(makeRequest, data));
+    },
+    /**
+     * Deletes this object on the server.
+     * @return Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('<org_id>')
+     * .then((org) => org.getAppDefinition('<app_def_id>'))
+     * .then((appDefinition) => appDefinition.getResourceType())
+     * .then((resourceType) => resourceType.delete())
+     * .catch(console.error)
+     * ```
+     */
+    delete: function del() {
+      const data = this.toPlainObject();
+      return makeRequest({
+        entityType: 'ResourceType',
+        action: 'delete',
+        params: getParams(data)
+      });
+    }
+  };
+}
+const getParams = data => ({
+  organizationId: data.sys.organization.sys.id,
+  appDefinitionId: data.sys.appDefinition.sys.id,
+  resourceTypeId: data.sys.id
+});
+const getUpsertParams = data => ({
+  name: data.name,
+  defaultFieldMapping: data.defaultFieldMapping
+});
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Resource Type data
+ * @return Wrapped Resource Type data
+ */
+export function wrapResourceType(makeRequest, data) {
+  const resourceType = toPlainObject(copy(data));
+  const ResourceTypeWithMethods = enhanceWithMethods(resourceType, createResourceTypeApi(makeRequest));
+  return freezeSys(ResourceTypeWithMethods);
+}
+export function wrapResourceTypeforEnvironment(makeRequest, data) {
+  const resourceType = toPlainObject(data);
+  return freezeSys(resourceType);
+}
+export const wrapResourceTypesForEnvironmentCollection = wrapCursorPaginatedCollection(wrapResourceTypeforEnvironment);

package/dist/es-modules/entities/resource.js

@@ -0,0 +1,7 @@
+import { wrapCursorPaginatedCollection } from '../common-utils';
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+export function wrapResource(makeRequest, data) {
+  const resource = toPlainObject(data);
+  return freezeSys(resource);
+}
+export const wrapResourceCollection = wrapCursorPaginatedCollection(wrapResource);

package/dist/es-modules/plain/entities/resource-type.js

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

package/dist/es-modules/plain/entities/resource.js

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

package/dist/es-modules/plain/plain-client.js

@@ -374,11 +374,21 @@ export const createPlainClient = (makeRequest, defaults) => {
       upsert: wrap(wrapParams, 'AppInstallation', 'upsert'),
       delete: wrap(wrapParams, 'AppInstallation', 'delete')
     },
+    resource: {
+      getMany: wrap(wrapParams, 'Resource', 'getMany')
+    },
     resourceProvider: {
       get: wrap(wrapParams, 'ResourceProvider', 'get'),
       upsert: wrap(wrapParams, 'ResourceProvider', 'upsert'),
       delete: wrap(wrapParams, 'ResourceProvider', 'delete')
     },
+    resourceType: {
+      get: wrap(wrapParams, 'ResourceType', 'get'),
+      getMany: wrap(wrapParams, 'ResourceType', 'getMany'),
+      upsert: wrap(wrapParams, 'ResourceType', 'upsert'),
+      delete: wrap(wrapParams, 'ResourceType', 'delete'),
+      getForEnvironment: wrap(wrapParams, 'ResourceType', 'getForEnvironment')
+    },
     extension: {
       get: wrap(wrapParams, 'Extension', 'get'),
       getMany: wrap(wrapParams, 'Extension', 'getMany'),

package/dist/typings/adapters/REST/endpoints/index.d.ts

@@ -35,7 +35,9 @@ import * as AccessToken from './access-token';
 import * as PreviewApiKey from './preview-api-key';
 import * as Release from './release';
 import * as ReleaseAction from './release-action';
+import * as Resource from './resource';
 import * as ResourceProvider from './resource-provider';
+import * as ResourceType from './resource-type';
 import * as Role from './role';
 import * as ScheduledAction from './scheduled-action';
 import * as Snapshot from './snapshot';
@@ -94,7 +96,9 @@ declare const _default: {
     PreviewApiKey: typeof PreviewApiKey;
     Release: typeof Release;
     ReleaseAction: typeof ReleaseAction;
+    Resource: typeof Resource;
     ResourceProvider: typeof ResourceProvider;
+    ResourceType: typeof ResourceType;
     Role: typeof Role;
     ScheduledAction: typeof ScheduledAction;
     Snapshot: typeof Snapshot;

package/dist/typings/adapters/REST/endpoints/resource-type.d.ts

@@ -0,0 +1,6 @@
+import type { RestEndpoint } from '../types';
+export declare const get: RestEndpoint<'ResourceType', 'get'>;
+export declare const upsert: RestEndpoint<'ResourceType', 'upsert'>;
+export declare const del: RestEndpoint<'ResourceType', 'delete'>;
+export declare const getMany: RestEndpoint<'ResourceType', 'getMany'>;
+export declare const getForEnvironment: RestEndpoint<'ResourceType', 'getForEnvironment'>;

package/dist/typings/adapters/REST/endpoints/resource.d.ts

@@ -0,0 +1,2 @@
+import type { RestEndpoint } from '../types';
+export declare const getMany: RestEndpoint<'Resource', 'getMany'>;

package/dist/typings/common-types.d.ts

@@ -59,6 +59,8 @@ import type { AppAccessTokenProps, CreateAppAccessTokenProps } from './entities/
 import type { ConceptProps, CreateConceptProps } from './entities/concept';
 import type { ConceptSchemeProps, CreateConceptSchemeProps } from './entities/concept-scheme';
 import type { ResourceProviderProps, UpsertResourceProviderProps } from './entities/resource-provider';
+import type { ResourceTypeProps, SpaceEnvResourceTypeProps, UpsertResourceTypeProps } from './entities/resource-type';
+import type { ResourceProps, ResourceQueryOptions } from './entities/resource';
 export interface DefaultElements<TPlainObject extends object = object> {
     toPlainObject(): TPlainObject;
 }
@@ -377,9 +379,15 @@ type MRInternal<UA extends boolean> = {
     (opts: MROpts<'ReleaseAction', 'get', UA>): MRReturn<'ReleaseAction', 'get'>;
     (opts: MROpts<'ReleaseAction', 'getMany', UA>): MRReturn<'ReleaseAction', 'getMany'>;
     (opts: MROpts<'ReleaseAction', 'queryForRelease', UA>): MRReturn<'ReleaseAction', 'queryForRelease'>;
+    (opts: MROpts<'Resource', 'getMany', UA>): MRReturn<'Resource', 'getMany'>;
     (opts: MROpts<'ResourceProvider', 'get', UA>): MRReturn<'ResourceProvider', 'get'>;
     (opts: MROpts<'ResourceProvider', 'upsert', UA>): MRReturn<'ResourceProvider', 'upsert'>;
     (opts: MROpts<'ResourceProvider', 'delete', UA>): MRReturn<'ResourceProvider', 'delete'>;
+    (opts: MROpts<'ResourceType', 'get', UA>): MRReturn<'ResourceType', 'get'>;
+    (opts: MROpts<'ResourceType', 'upsert', UA>): MRReturn<'ResourceType', 'upsert'>;
+    (opts: MROpts<'ResourceType', 'delete', UA>): MRReturn<'ResourceType', 'delete'>;
+    (opts: MROpts<'ResourceType', 'getForEnvironment', UA>): MRReturn<'ResourceType', 'getForEnvironment'>;
+    (opts: MROpts<'ResourceType', 'getMany', UA>): MRReturn<'ResourceType', 'getMany'>;
     (opts: MROpts<'Role', 'get', UA>): MRReturn<'Role', 'get'>;
     (opts: MROpts<'Role', 'getMany', UA>): MRReturn<'Role', 'getMany'>;
     (opts: MROpts<'Role', 'getManyForOrganization', UA>): MRReturn<'Role', 'getManyForOrganization'>;
@@ -508,6 +516,15 @@ export interface Adapter {
  * @private
  */
 export type MRActions = {
+    Resource: {
+        getMany: {
+            params: GetResourceParams & {
+                query?: ResourceQueryOptions;
+            };
+            headers?: RawAxiosRequestHeaders;
+            return: CursorPaginatedCollectionProp<ResourceProps>;
+        };
+    };
     ResourceProvider: {
         get: {
             params: GetResourceProviderParams;
@@ -524,6 +541,32 @@ export type MRActions = {
             return: any;
         };
     };
+    ResourceType: {
+        get: {
+            params: GetResourceTypeParams;
+            return: ResourceTypeProps;
+        };
+        getMany: {
+            params: Omit<GetResourceTypeParams, 'resourceTypeId'>;
+            return: CollectionProp<ResourceTypeProps>;
+        };
+        upsert: {
+            params: GetResourceTypeParams;
+            payload: UpsertResourceTypeProps;
+            headers?: RawAxiosRequestHeaders;
+            return: ResourceTypeProps;
+        };
+        delete: {
+            params: GetResourceTypeParams;
+            return: any;
+        };
+        getForEnvironment: {
+            params: GetSpaceEnvironmentParams & {
+                query?: BasicCursorPaginationOptions;
+            };
+            return: CursorPaginatedCollectionProp<SpaceEnvResourceTypeProps>;
+        };
+    };
     Http: {
         get: {
             params: {
@@ -2378,6 +2421,12 @@ export type GetUserUIConfigParams = GetUIConfigParams;
 export type GetResourceProviderParams = GetOrganizationParams & {
     appDefinitionId: string;
 };
+export type GetResourceTypeParams = GetResourceProviderParams & {
+    resourceTypeId: string;
+};
+export type GetResourceParams = GetSpaceEnvironmentParams & {
+    resourceTypeId: string;
+};
 export type QueryParams = {
     query?: QueryOptions;
 };

package/dist/typings/constants/editor-interface-defaults/controls-defaults.d.ts

@@ -91,7 +91,7 @@ export declare const FIELD_TYPES: Array<keyof typeof INTERNAL_TO_API>;
  * - Assets
  * - File
  */
-export declare function toInternalFieldType(api: Partial<ContentFields>): "File" | "Entries" | "Boolean" | "Symbol" | "Number" | "Asset" | "Entry" | "Text" | "RichText" | "Integer" | "Date" | "Object" | "Location" | "Resource" | "Symbols" | "Assets" | "Resources" | undefined;
+export declare function toInternalFieldType(api: Partial<ContentFields>): "File" | "Entries" | "Boolean" | "Symbol" | "Number" | "Asset" | "Entry" | "Resource" | "Text" | "RichText" | "Integer" | "Date" | "Object" | "Location" | "Symbols" | "Assets" | "Resources" | undefined;
 export declare const DEFAULTS_WIDGET: {
     Text: {
         widgetId: string;

package/dist/typings/create-environment-api.d.ts

@@ -15,6 +15,7 @@ import type { CreateExtensionProps } from './entities/extension';
 import type { CreateLocaleProps } from './entities/locale';
 import type { TagVisibility } from './entities/tag';
 import type { CreateAppAccessTokenProps } from './entities/app-access-token';
+import type { ResourceQueryOptions } from './entities/resource';
 /**
  * @private
  */
@@ -1489,4 +1490,53 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
     getEnvironmentTemplateInstallations(environmentTemplateId: string, { installationId, ...query }?: BasicCursorPaginationOptions & {
         installationId?: string;
     }): Promise<import("./common-types").CursorPaginatedCollection<import("./entities/environment-template-installation").EnvironmentTemplateInstallation, import("./entities/environment-template-installation").EnvironmentTemplateInstallationProps>>;
+    /**
+     * Gets a collection of all resource types based on native external references app installations in the environment
+     * @param query - BasicCursorPaginationOptions
+     * @return Promise for a collection of ResourceTypes
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getResourceTypes({limit: 10}))
+     * .then((installations) => console.log(installations.items))
+     * .catch(console.error)
+     * ```
+     */
+    getResourceTypes(query?: BasicCursorPaginationOptions): Promise<import("./common-types").CursorPaginatedCollectionProp<import("./export-types").SpaceEnvResourceTypeProps>>;
+    /**
+     * Gets a collection of all resources for a given resource type based on native external references app installations in the environment
+     * @param resourceTypeId - Id of the resourceType to get its resources
+     * @param query - Either LookupQuery options with 'sys.urn[in]' param or a Search query with 'query' param, in both cases you can add pagination options
+     * @return Promise for a collection of Resources for a given resourceTypeId
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * // Search Query
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * // <search_query> is a string you want to search for in the external resources
+     * .then((environment) => environment.getResourcesForResourceType('<resource_type_id>', {query: '<search_query>', limit: 10}))
+     * .then((installations) => console.log(installations.items))
+     * .catch(console.error)
+     *
+     * // Lookup query
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getResourcesForResourceType('<resource_type_id>', {'sys.urn[in]': '<resource_urn1>,<resource_urn2>', limit: 10}))
+     * .then((installations) => console.log(installations.items))
+     * .catch(console.error)
+     * ```
+     */
+    getResourcesForResourceType(resourceTypeId: string, query?: ResourceQueryOptions): Promise<import("./common-types").CursorPaginatedCollectionProp<import("./entities/resource").ResourceProps>>;
 };

package/dist/typings/entities/index.d.ts

@@ -53,6 +53,8 @@ import * as workflowDefinition from './workflow-definition';
 import * as concept from './concept';
 import * as conceptScheme from './concept-scheme';
 import * as resourceProvider from './resource-provider';
+import * as resourceType from './resource-type';
+import * as resource from './resource';
 declare const _default: {
     accessToken: typeof accessToken;
     appAction: typeof appAction;
@@ -91,6 +93,8 @@ declare const _default: {
     release: typeof release;
     releaseAction: typeof releaseAction;
     resourceProvider: typeof resourceProvider;
+    resourceType: typeof resourceType;
+    resource: typeof resource;
     role: typeof role;
     scheduledAction: typeof scheduledAction;
     snapshot: typeof snapshot;

package/dist/typings/entities/resource-provider.d.ts

@@ -1,4 +1,5 @@
-import type { BasicMetaSysProps, DefaultElements, MakeRequest, SysLink } from '../common-types';
+import type { BasicMetaSysProps, CollectionProp, DefaultElements, MakeRequest, SysLink } from '../common-types';
+import type { ResourceType, UpsertResourceTypeProps } from './resource-type';
 export type ResourceProviderProps = {
     /**
      * System metadata
@@ -24,6 +25,9 @@ export type UpsertResourceProviderProps = Omit<ResourceProviderProps, 'sys'> & {
 export interface ResourceProvider extends ResourceProviderProps, DefaultElements<ResourceProviderProps> {
     upsert(): Promise<ResourceProvider>;
     delete(): Promise<void>;
+    upsertResourceType(id: string, data: UpsertResourceTypeProps): Promise<ResourceType>;
+    getResourceType(id: string): Promise<ResourceType>;
+    getResourceTypes(): Promise<CollectionProp<ResourceType>>;
 }
 /**
  * @private

package/dist/typings/entities/resource-type.d.ts

@@ -0,0 +1,52 @@
+import type { BasicMetaSysProps, CursorPaginatedCollectionProp, DefaultElements, MakeRequest, SysLink } from '../common-types';
+export type ResourceTypeProps = {
+    /**
+     * System metadata
+     */
+    sys: Omit<BasicMetaSysProps, 'version'> & {
+        appDefinition: SysLink;
+        resourceProvider: SysLink;
+        organization: SysLink;
+    };
+    /**
+     * Resource Type name
+     */
+    name: string;
+    /**
+     * Resource Type defaultFieldMapping
+     */
+    defaultFieldMapping: {
+        title: string;
+        subtitle?: string;
+        description?: string;
+        externalUrl?: string;
+        image?: {
+            url: string;
+            altText?: string;
+        };
+        badge?: {
+            label: string;
+            variant: string;
+        };
+    };
+};
+declare const publicResourceTypeFields: readonly ["name"];
+type OptionalSysFields = 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy' | 'appDefinition' | 'organization';
+export type SpaceEnvResourceTypeProps = Pick<ResourceTypeProps, typeof publicResourceTypeFields[number]> & {
+    sys: Partial<Pick<ResourceTypeProps['sys'], OptionalSysFields>> & Omit<ResourceTypeProps['sys'], OptionalSysFields>;
+};
+export type UpsertResourceTypeProps = Omit<ResourceTypeProps, 'sys'>;
+export interface ResourceType extends ResourceTypeProps, DefaultElements<ResourceTypeProps> {
+    upsert(): Promise<ResourceType>;
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Resource Type data
+ * @return Wrapped Resource Type data
+ */
+export declare function wrapResourceType(makeRequest: MakeRequest, data: ResourceTypeProps): ResourceType;
+export declare function wrapResourceTypeforEnvironment(makeRequest: MakeRequest, data: SpaceEnvResourceTypeProps): SpaceEnvResourceTypeProps;
+export declare const wrapResourceTypesForEnvironmentCollection: (makeRequest: MakeRequest, data: CursorPaginatedCollectionProp<SpaceEnvResourceTypeProps>) => CursorPaginatedCollectionProp<SpaceEnvResourceTypeProps>;
+export {};