contentful-management 11.60.3 → 12.0.0-beta.10

package/dist/types/entities/editor-interface.js

@@ -0,0 +1,47 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createEditorInterfaceApi(makeRequest) {
+    return {
+        update: function () {
+            const self = this;
+            const raw = self.toPlainObject();
+            return makeRequest({
+                entityType: 'EditorInterface',
+                action: 'update',
+                params: {
+                    spaceId: self.sys.space.sys.id,
+                    environmentId: self.sys.environment.sys.id,
+                    contentTypeId: self.sys.contentType.sys.id,
+                },
+                payload: raw,
+            }).then((response) => wrapEditorInterface(makeRequest, response));
+        },
+        getControlForField: function (fieldId) {
+            const self = this;
+            const result = (self.controls || []).filter((control) => {
+                return control.fieldId === fieldId;
+            });
+            return result && result.length > 0 ? result[0] : null;
+        },
+    };
+}
+/**
+ * @private
+ */
+function wrapEditorInterface(makeRequest, data) {
+    const editorInterface = toPlainObject(copy(data));
+    const editorInterfaceWithMethods = enhanceWithMethods(editorInterface, createEditorInterfaceApi(makeRequest));
+    return freezeSys(editorInterfaceWithMethods);
+}
+/**
+ * @private
+ */
+const wrapEditorInterfaceCollection = wrapCollection(wrapEditorInterface);
+
+export { wrapEditorInterface, wrapEditorInterfaceCollection };

package/dist/types/entities/entry.d.ts

@@ -0,0 +1,57 @@
+import type { CollectionProp, DefaultElements, EntityMetaSysProps, KeyValueMap, Link, MakeRequest, MetadataProps } from '../common-types.js';
+import type { ContentfulEntryApi } from '../create-entry-api.js';
+import type { AssetProps } from './asset.js';
+export interface EntryMetaSysProps extends EntityMetaSysProps {
+    contentType: Link<'ContentType'>;
+    automationTags: Link<'Tag'>[];
+}
+export type EntryProps<T = KeyValueMap, S = unknown> = {
+    sys: EntryMetaSysProps & S;
+    metadata?: MetadataProps;
+    fields: T;
+};
+export type CreateEntryProps<TFields = KeyValueMap> = Omit<EntryProps<TFields>, 'sys'>;
+export type EntryReferenceError = {
+    sys: {
+        type: 'error';
+        id: 'notResolvable';
+    };
+    details: {
+        type: 'Link';
+        linkType: 'Entry' | 'Asset';
+        id: string;
+    };
+};
+export interface EntryReferenceProps extends CollectionProp<EntryProps> {
+    includes?: {
+        Entry?: EntryProps[];
+        Asset?: AssetProps[];
+    };
+    errors?: EntryReferenceError[];
+}
+export type EntryReferenceOptionsProps = {
+    include?: number;
+};
+export interface Entry extends EntryProps, DefaultElements<EntryProps>, ContentfulEntryApi {
+}
+export type WithResourceName<T extends {
+    sys: unknown;
+}> = T extends {
+    sys: infer Sys;
+} ? Omit<T, 'sys'> & {
+    sys: Sys & {
+        urn: string;
+    };
+} : never;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw entry data
+ * @return Wrapped entry data
+ */
+export declare function wrapEntry(makeRequest: MakeRequest, data: EntryProps): Entry;
+/**
+ * Data is also mixed in with link getters if links exist and includes were requested
+ * @private
+ */
+export declare const wrapEntryCollection: (makeRequest: MakeRequest, data: CollectionProp<EntryProps<KeyValueMap, unknown>>) => import("../common-types.js").Collection<Entry, EntryProps<KeyValueMap, unknown>>;

package/dist/types/entities/entry.js

@@ -0,0 +1,24 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import createEntryApi from '../create-entry-api.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw entry data
+ * @return Wrapped entry data
+ */
+function wrapEntry(makeRequest, data) {
+    const entry = toPlainObject(copy(data));
+    const entryWithMethods = enhanceWithMethods(entry, createEntryApi(makeRequest));
+    return freezeSys(entryWithMethods);
+}
+/**
+ * Data is also mixed in with link getters if links exist and includes were requested
+ * @private
+ */
+const wrapEntryCollection = wrapCollection(wrapEntry);
+
+export { wrapEntry, wrapEntryCollection };

package/dist/types/entities/environment-alias.d.ts

@@ -0,0 +1,72 @@
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
+export type EnvironmentAliasProps = {
+    /**
+     * System meta data
+     */
+    sys: BasicMetaSysProps & {
+        space: Link<'Space'>;
+    };
+    environment: Link<'Environment'>;
+};
+export type CreateEnvironmentAliasProps = Omit<EnvironmentAliasProps, 'sys'>;
+export interface EnvironmentAlias extends EnvironmentAliasProps, DefaultElements<EnvironmentAliasProps> {
+    /**
+     * Sends an update to the server with any changes made to the object's properties. Currently, you can only change the id of the alias's underlying environment. See the example below.
+     * @memberof EnvironmentAlias
+     * @func update
+     * @return {Promise<EnvironmentAlias>} Object returned from the server with updated changes.
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironmentAlias('<environment_alias_id>'))
+     * .then((alias) => {
+     *   alias.environment.sys.id = '<environment_id>'
+     *   return alias.update()
+     * })
+     * .then((alias) => console.log(`alias ${alias.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<EnvironmentAlias>;
+    /**
+     * Deletes this object on the server.
+     * @memberof EnvironmentAlias
+     * @func delete
+     * @return {Promise<void>} Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironmentAlias('<environment_alias_id>'))
+     * .then((alias) => {
+     *   return alias.delete()
+     * })
+     * .then(() => console.log(`Alias deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias data
+ * @return Wrapped environment alias data
+ */
+export declare function wrapEnvironmentAlias(makeRequest: MakeRequest, data: EnvironmentAliasProps): EnvironmentAlias;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias collection data
+ * @return Wrapped environment alias collection data
+ */
+export declare const wrapEnvironmentAliasCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<EnvironmentAliasProps>) => import("../common-types.js").Collection<EnvironmentAlias, EnvironmentAliasProps>;

package/dist/types/entities/environment-alias.js

@@ -0,0 +1,55 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createEnvironmentAliasApi(makeRequest) {
+    const getParams = (alias) => ({
+        spaceId: alias.sys.space.sys.id,
+        environmentAliasId: alias.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentAlias',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapEnvironmentAlias(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentAlias',
+                action: 'delete',
+                params: getParams(raw),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias data
+ * @return Wrapped environment alias data
+ */
+function wrapEnvironmentAlias(makeRequest, data) {
+    const alias = toPlainObject(copy(data));
+    const enhancedAlias = enhanceWithMethods(alias, createEnvironmentAliasApi(makeRequest));
+    return freezeSys(enhancedAlias);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias collection data
+ * @return Wrapped environment alias collection data
+ */
+const wrapEnvironmentAliasCollection = wrapCollection(wrapEnvironmentAlias);
+
+export { wrapEnvironmentAlias, wrapEnvironmentAliasCollection };

package/dist/types/entities/environment-template-installation.d.ts

@@ -0,0 +1,56 @@
+import type { BasicMetaSysProps, DefaultElements, ISO8601Timestamp, Link, MakeRequest, VersionedLink } from '../common-types.js';
+type JsonObject = {
+    [Key in string]?: JsonValue;
+};
+type JsonArray = Array<JsonValue>;
+type JsonValue = string | number | boolean | JsonObject | JsonArray | null;
+declare enum EnvironmentTemplateInstallationStatuses {
+    created = "created",
+    inProgress = "inProgress",
+    failed = "failed",
+    succeeded = "succeeded",
+    disconnected = "disconnected",
+    inRetry = "inRetry"
+}
+export type EnvironmentTemplateInstallationStatus = keyof typeof EnvironmentTemplateInstallationStatuses;
+export type EnvironmentTemplateInstallationProps = {
+    sys: BasicMetaSysProps & {
+        type: 'EnvironmentTemplateInstallation';
+        space: Link<'Space'>;
+        template: VersionedLink<'Template'>;
+        status: EnvironmentTemplateInstallationStatus;
+        createdAt: ISO8601Timestamp;
+        updatedAt: ISO8601Timestamp;
+        createdBy: Link<'User' | 'AppDefinition'>;
+        updatedBy: Link<'User' | 'AppDefinition'>;
+        completedAt?: ISO8601Timestamp;
+        errors?: JsonArray;
+        environment: Link<'Environment'>;
+        version: number;
+    };
+};
+export type CreateEnvironmentTemplateInstallationProps = {
+    version: number;
+    takeover?: {
+        items: Link<'ContentType'>[];
+    };
+    changeSet?: Link<'ChangeSet'>;
+};
+export type ValidateEnvironmentTemplateInstallationProps = Omit<CreateEnvironmentTemplateInstallationProps, 'version'>;
+export type ValidationFinding = {
+    message: string;
+    details: Record<string, unknown>;
+};
+export type EnvironmentTemplateValidationProps<T = ValidationFinding> = {
+    sys: {
+        type: 'Array';
+        environment: Link<'Environment'>;
+        space: Link<'Space'>;
+        changeSet: Link<'ChangeSet'>;
+    };
+    items: T[];
+};
+export type EnvironmentTemplateInstallation = EnvironmentTemplateInstallationProps & DefaultElements<EnvironmentTemplateInstallationProps>;
+export declare function wrapEnvironmentTemplateInstallation(makeRequest: MakeRequest, data: EnvironmentTemplateInstallationProps): EnvironmentTemplateInstallation;
+export declare const wrapEnvironmentTemplateInstallationCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>) => import("../common-types.js").CursorPaginatedCollection<EnvironmentTemplateInstallation, EnvironmentTemplateInstallationProps>;
+export {};

package/dist/types/entities/environment-template-installation.js

@@ -0,0 +1,20 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+
+var EnvironmentTemplateInstallationStatuses;
+(function (EnvironmentTemplateInstallationStatuses) {
+    EnvironmentTemplateInstallationStatuses["created"] = "created";
+    EnvironmentTemplateInstallationStatuses["inProgress"] = "inProgress";
+    EnvironmentTemplateInstallationStatuses["failed"] = "failed";
+    EnvironmentTemplateInstallationStatuses["succeeded"] = "succeeded";
+    EnvironmentTemplateInstallationStatuses["disconnected"] = "disconnected";
+    EnvironmentTemplateInstallationStatuses["inRetry"] = "inRetry";
+})(EnvironmentTemplateInstallationStatuses || (EnvironmentTemplateInstallationStatuses = {}));
+function wrapEnvironmentTemplateInstallation(makeRequest, data) {
+    const environmentTemplate = toPlainObject(copy(data));
+    return freezeSys(environmentTemplate);
+}
+const wrapEnvironmentTemplateInstallationCollection = wrapCursorPaginatedCollection(wrapEnvironmentTemplateInstallation);
+
+export { wrapEnvironmentTemplateInstallation, wrapEnvironmentTemplateInstallationCollection };

package/dist/types/entities/environment-template.d.ts

@@ -0,0 +1,40 @@
+import type { BasicMetaSysProps, Link, MakeRequest, DefaultElements } from '../common-types.js';
+import type { ContentfulEnvironmentTemplateApi } from '../create-environment-template-api.js';
+import type { ContentTypeProps } from './content-type.js';
+import type { EditorInterfaceProps } from './editor-interface.js';
+export type Hint = {
+    operation: 'renameFieldId';
+    fieldId: string;
+    previousFieldId: string;
+};
+export interface EditorInterfaceTemplateProps extends Omit<EditorInterfaceProps, 'sys'> {
+    contentTypeTemplate: Link<'ContentTypeTemplate'>;
+}
+export interface ContentTypeTemplateProps extends Omit<ContentTypeProps, 'sys'> {
+    id: string;
+    basedOn?: {
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+        contentType: Link<'ContentType'>;
+    };
+    hints?: Array<Hint>;
+}
+export type EnvironmentTemplateProps = {
+    sys: BasicMetaSysProps & {
+        version: number;
+        organization: Link<'Organization'>;
+    };
+    name: string;
+    description?: string;
+    versionName: string;
+    versionDescription?: string;
+    entities: {
+        contentTypeTemplates: Array<ContentTypeTemplateProps>;
+        editorInterfaceTemplates: Array<EditorInterfaceTemplateProps>;
+    };
+    forTemplatedSpaces?: boolean;
+};
+export type CreateEnvironmentTemplateProps = Omit<EnvironmentTemplateProps, 'sys'>;
+export type EnvironmentTemplate = EnvironmentTemplateProps & DefaultElements<EnvironmentTemplateProps> & ContentfulEnvironmentTemplateApi;
+export declare function wrapEnvironmentTemplate(makeRequest: MakeRequest, data: EnvironmentTemplateProps, organizationId: string): EnvironmentTemplate;
+export declare const wrapEnvironmentTemplateCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CursorPaginatedCollectionProp<EnvironmentTemplateProps>, organizationId: string) => import("../common-types.js").CursorPaginatedCollection<EnvironmentTemplate, EnvironmentTemplateProps>;

package/dist/types/entities/environment-template.js

@@ -0,0 +1,15 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCursorPaginatedCollection } from '../common-utils.js';
+import { createEnvironmentTemplateApi } from '../create-environment-template-api.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+function wrapEnvironmentTemplate(makeRequest, data, organizationId) {
+    const environmentTemplate = toPlainObject(copy(data));
+    const environmentTemplateApi = createEnvironmentTemplateApi(makeRequest, organizationId);
+    const enhancedEnvironmentTemplate = enhanceWithMethods(environmentTemplate, environmentTemplateApi);
+    return freezeSys(enhancedEnvironmentTemplate);
+}
+const wrapEnvironmentTemplateCollection = wrapCursorPaginatedCollection(wrapEnvironmentTemplate);
+
+export { wrapEnvironmentTemplate, wrapEnvironmentTemplateCollection };

package/dist/types/entities/environment.d.ts

@@ -0,0 +1,38 @@
+import type { ContentfulEnvironmentAPI } from '../create-environment-api.js';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
+type EnvironmentMetaSys = BasicMetaSysProps & {
+    status: Link<'Status'>;
+    space: Link<'Space'>;
+    aliases?: Array<Link<'EnvironmentAlias'>>;
+    aliasedEnvironment?: Link<'Environment'>;
+};
+export type EnvironmentProps = {
+    /**
+     * System metadata
+     */
+    sys: EnvironmentMetaSys;
+    /**
+     * Name of the environment
+     */
+    name: string;
+};
+export type CreateEnvironmentProps = Partial<Omit<EnvironmentProps, 'sys'>>;
+export type Environment = ContentfulEnvironmentAPI & EnvironmentProps & DefaultElements<EnvironmentProps>;
+/**
+ * This method creates the API for the given environment with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with a environment id, so the base path for requests now has the
+ * environment id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for a Environment
+ * @return
+ */
+export declare function wrapEnvironment(makeRequest: MakeRequest, data: EnvironmentProps): Environment;
+/**
+ * This method wraps each environment in a collection with the environment API. See wrapEnvironment
+ * above for more details.
+ * @private
+ */
+export declare const wrapEnvironmentCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<EnvironmentProps>) => import("../common-types.js").Collection<Environment, EnvironmentProps>;
+export {};

package/dist/types/entities/environment.js

@@ -0,0 +1,31 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import createEnvironmentApi from '../create-environment-api.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * This method creates the API for the given environment with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with a environment id, so the base path for requests now has the
+ * environment id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for a Environment
+ * @return
+ */
+function wrapEnvironment(makeRequest, data) {
+    // do not pollute generated typings
+    const environment = toPlainObject(copy(data));
+    const environmentApi = createEnvironmentApi(makeRequest);
+    const enhancedEnvironment = enhanceWithMethods(environment, environmentApi);
+    return freezeSys(enhancedEnvironment);
+}
+/**
+ * This method wraps each environment in a collection with the environment API. See wrapEnvironment
+ * above for more details.
+ * @private
+ */
+const wrapEnvironmentCollection = wrapCollection(wrapEnvironment);
+
+export { wrapEnvironment, wrapEnvironmentCollection };

package/dist/types/entities/extension.d.ts

@@ -0,0 +1,103 @@
+import type { FieldType } from './field-type.js';
+import type { DefinedParameters, InstallationParameterType, ParameterDefinition } from './widget-parameters.js';
+import type { DefaultElements, BasicMetaSysProps, MakeRequest, Link } from '../common-types.js';
+import type { SetRequired, RequireExactlyOne } from 'type-fest';
+type ExtensionSysProps = BasicMetaSysProps & {
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    srcdocSha256?: string;
+};
+export type ExtensionProps = {
+    sys: ExtensionSysProps;
+    extension: {
+        /**
+         * Extension name
+         */
+        name: string;
+        /**
+         * Field types where an extension can be used
+         */
+        fieldTypes: FieldType[];
+        /**
+         * URL where the root HTML document of the extension can be found
+         */
+        src?: string;
+        /**
+         * String representation of the extension (e.g. inline HTML code)
+         */
+        srcdoc?: string;
+        /**
+         * Parameter definitions
+         */
+        parameters?: {
+            instance?: ParameterDefinition[];
+            installation?: ParameterDefinition<InstallationParameterType>[];
+        };
+        /**
+         * Controls the location of the extension. If true it will be rendered on the sidebar instead of replacing the field's editing control
+         */
+        sidebar?: boolean;
+    };
+    /**
+     * Values for installation parameters
+     */
+    parameters?: DefinedParameters;
+};
+export type CreateExtensionProps = {
+    extension: RequireExactlyOne<SetRequired<ExtensionProps['extension'], 'name' | 'fieldTypes' | 'sidebar'>, 'src' | 'srcdoc'>;
+};
+export interface Extension extends ExtensionProps, DefaultElements<ExtensionProps> {
+    /**
+     * 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.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getUiExtension('<ui_extension_id>'))
+     * .then((extension) => {
+     *   extension.extension.name = 'New UI Extension name'
+     *   return extension.update()
+     * })
+     * .then((extension) => console.log(`UI Extension ${extension.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<Extension>;
+    /**
+     * 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.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getUiExtension('<ui_extension_id>'))
+     * .then((extension) => extension.delete())
+     * .then(() => console.log(`UI Extension deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw UI Extension data
+ * @return Wrapped UI Extension data
+ */
+export declare function wrapExtension(makeRequest: MakeRequest, data: ExtensionProps): Extension;
+/**
+ * @private
+ */
+export declare const wrapExtensionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<ExtensionProps>) => import("../common-types.js").Collection<Extension, ExtensionProps>;
+export {};

package/dist/types/entities/extension.js

@@ -0,0 +1,51 @@
+import copy from 'fast-copy';
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import enhanceWithMethods from '../enhance-with-methods.js';
+import { wrapCollection } from '../common-utils.js';
+
+/**
+ * @private
+ */
+function createExtensionApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        environmentId: data.sys.environment.sys.id,
+        extensionId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Extension',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((response) => wrapExtension(makeRequest, response));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Extension',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw UI Extension data
+ * @return Wrapped UI Extension data
+ */
+function wrapExtension(makeRequest, data) {
+    const extension = toPlainObject(copy(data));
+    const extensionWithMethods = enhanceWithMethods(extension, createExtensionApi(makeRequest));
+    return freezeSys(extensionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapExtensionCollection = wrapCollection(wrapExtension);
+
+export { wrapExtension, wrapExtensionCollection };

package/dist/types/entities/function-log.d.ts

@@ -0,0 +1,46 @@
+import type { Link, DefaultElements } from '../common-types.js';
+import type { MakeRequest } from '../common-types.js';
+export type FunctionLogProps = {
+    sys: {
+        id: string;
+        type: 'FunctionLog';
+        createdBy: Link<'User'>;
+        createdAt: string;
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+        appDefinition: Link<'AppDefinition'>;
+    };
+    severity: {
+        info: number;
+        warn: number;
+        error: number;
+    };
+    requestId: string;
+    event: {
+        type: string;
+        query: string;
+        isIntrospectionQuery: boolean;
+        variables: Record<string, any>;
+    };
+    messages: Array<{
+        timestamp: number;
+        type: 'INFO' | 'ERROR' | 'WARN';
+        message: string;
+    }>;
+};
+export interface FunctionLog extends FunctionLogProps, DefaultElements<FunctionLogProps> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+export declare function wrapFunctionLog(makeRequest: MakeRequest, data: FunctionLogProps): FunctionLogProps;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-function data
+ * @return Wrapped App Function collection data
+ */
+export declare const wrapFunctionLogCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<FunctionLogProps>) => import("../common-types.js").Collection<FunctionLogProps, FunctionLogProps>;