contentful-management 11.64.0-new-beta.5 → 11.65.0

package/dist/typings/entities/app-installation.d.ts

@@ -0,0 +1,70 @@
+import type { DefaultElements, BasicMetaSysProps, SysLink, MakeRequest } from '../common-types';
+import type { Except } from 'type-fest';
+import type { FreeFormParameters } from './widget-parameters';
+export type AppInstallationProps = {
+    sys: Omit<BasicMetaSysProps, 'id'> & {
+        appDefinition: SysLink;
+        environment: SysLink;
+        space: SysLink;
+        organization: SysLink;
+    };
+    /**
+     * Free-form installation parameters (API limits stringified length to 32KB)
+     */
+    parameters?: FreeFormParameters;
+};
+export type CreateAppInstallationProps = Except<AppInstallationProps, 'sys'>;
+export interface AppInstallation extends AppInstallationProps, DefaultElements<AppInstallationProps> {
+    /**
+     * 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.getAppInstallation('<app_definition_id>'))
+     * .then((appInstallation) => {
+     *    appInstallation.parameters.someParameter = 'New Value'
+     *    return appInstallation.update()
+     * })
+     * .then((appInstallation) => console.log(`App installation ${appInstallation.sys.id} was updated`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<AppInstallation>;
+    /**
+     * 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.getAppInstallation('<app_definition_id>'))
+     * .then((appInstallation) => appInstallation.delete())
+     * .then(() => console.log(`App installation deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Installation data
+ * @return Wrapped App installation data
+ */
+export declare function wrapAppInstallation(makeRequest: MakeRequest, data: AppInstallationProps): AppInstallation;
+/**
+ * @private
+ */
+export declare const wrapAppInstallationCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppInstallationProps>) => import("../common-types").Collection<AppInstallation, AppInstallationProps>;

package/dist/typings/entities/app-key.d.ts

@@ -0,0 +1,77 @@
+import type { Except } from 'type-fest';
+import type { BasicMetaSysProps, DefaultElements, MakeRequest, SysLink } from '../common-types';
+type AppKeySys = Except<BasicMetaSysProps, 'version'> & {
+    appDefinition: SysLink;
+    organization: SysLink;
+};
+export interface JWK {
+    alg: 'RS256';
+    kty: 'RSA';
+    use: 'sig';
+    x5c: [string];
+    kid: string;
+    x5t: string;
+}
+export type AppKeyProps = {
+    /**
+     * System metadata
+     */
+    sys: AppKeySys;
+    /**
+     * JSON Web Key
+     */
+    jwk: JWK;
+    /**
+     * If generated, private key is returned
+     */
+    generated?: {
+        /**
+         * Base64 PEM
+         */
+        privateKey: string;
+    };
+};
+export type CreateAppKeyProps = {
+    /**
+     * Toggle for automatic private key generation
+     */
+    generate?: boolean;
+    /**
+     * JSON Web Key, required if generate is falsy
+     */
+    jwk?: JWK;
+};
+export interface AppKey extends AppKeyProps, DefaultElements<AppKeyProps> {
+    /**
+     * 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('<organization_id>')
+     * .then((organization) => organization.getAppKey(<api-key-id>))
+     * .then((signingSecret) => signingSecret.delete())
+     * .then(() => console.log('signingSecret deleted'))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppKey data
+ * @return Wrapped AppKey data
+ */
+export declare function wrapAppKey(makeRequest: MakeRequest, data: AppKeyProps): AppKey;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Key collection data
+ * @return Wrapped App Key collection data
+ */
+export declare const wrapAppKeyCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppKeyProps>) => import("../common-types").Collection<AppKey, AppKeyProps>;
+export {};

package/dist/typings/entities/app-upload.d.ts

@@ -0,0 +1,44 @@
+import type { Except } from 'type-fest';
+import type { BasicMetaSysProps, SysLink, DefaultElements, MakeRequest } from '../common-types';
+type AppUploadSys = Except<BasicMetaSysProps, 'version'>;
+export type AppUploadProps = {
+    sys: AppUploadSys & {
+        expiresAt: string;
+        organization: SysLink;
+    };
+};
+export interface AppUpload extends AppUploadProps, DefaultElements<AppUploadProps> {
+    /**
+     * 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.getAppUpload('<app_upload_id>'))
+     * .then((appUpload) => appUpload.delete())
+     * .then(() => console.log(`App Upload deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Upload data
+ * @return Wrapped App Upload data
+ */
+export declare function wrapAppUpload(makeRequest: MakeRequest, data: AppUploadProps): AppUpload;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw App Upload collection data
+ * @return Wrapped App Upload collection data
+ */
+export declare const wrapAppUploadCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AppUploadProps>) => import("../common-types").Collection<AppUpload, AppUploadProps>;
+export {};

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

@@ -0,0 +1,282 @@
+import type { Stream } from 'stream';
+import type { MetaSysProps, DefaultElements, EntityMetaSysProps, MetadataProps, MakeRequest, CursorPaginatedCollectionProp } from '../common-types';
+export type AssetProps<S = {}> = {
+    sys: EntityMetaSysProps & S;
+    fields: {
+        /** Title for this asset */
+        title: {
+            [key: string]: string;
+        };
+        /** Description for this asset */
+        description?: {
+            [key: string]: string;
+        };
+        /** File object for this asset */
+        file: {
+            [key: string]: {
+                fileName: string;
+                contentType: string;
+                /** Url where the file is available to be downloaded from, into the Contentful asset system. After the asset is processed this field is gone. */
+                upload?: string;
+                /** Url where the file is available at the Contentful media asset system. This field won't be available until the asset is processed. */
+                url?: string;
+                /** Details for the file, depending on file type (example: image size in bytes, etc) */
+                details?: Record<string, any>;
+                uploadFrom?: Record<string, any>;
+            };
+        };
+    };
+    metadata?: MetadataProps;
+};
+export type CreateAssetProps = Omit<AssetProps, 'sys'>;
+export type CreateAssetFromFilesOptions = {
+    uploadTimeout?: number;
+};
+export interface AssetFileProp {
+    sys: MetaSysProps;
+    fields: {
+        title: {
+            [key: string]: string;
+        };
+        description: {
+            [key: string]: string;
+        };
+        file: {
+            [key: string]: {
+                file: string | ArrayBuffer | Stream;
+                contentType: string;
+                fileName: string;
+            };
+        };
+    };
+}
+export interface AssetProcessingForLocale {
+    processingCheckWait?: number;
+    processingCheckRetries?: number;
+}
+type AssetApi = {
+    /**
+     * Triggers asset processing after an upload, for the files uploaded to all locales of an asset.
+     * @param options - Additional options for processing
+     * @prop options.processingCheckWait - Time in milliseconds to wait before checking again if the asset has been processed (default: 500ms)
+     * @prop options.processingCheckRetries - Maximum amount of times to check if the asset has been processed (default: 5)
+     * @return Object returned from the server with updated metadata.
+     * @throws {AssetProcessingTimeout} If the asset takes too long to process. If this happens, retrieve the asset again, and if the url property is available, then processing has succeeded. If not, your file might be damaged.
+     * @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.createAssetWithId('<asset_id>', {
+     *   title: {
+     *     'en-US': 'Playsam Streamliner',
+     *     'de-DE': 'Playsam Streamliner'
+     *   },
+     *   file: {
+     *     'en-US': {
+     *       contentType: 'image/jpeg',
+     *       fileName: 'example.jpeg',
+     *       upload: 'https://example.com/example.jpg'
+     *     },
+     *     'de-DE': {
+     *       contentType: 'image/jpeg',
+     *       fileName: 'example.jpeg',
+     *       upload: 'https://example.com/example-de.jpg'
+     *     }
+     *   }
+     * }))
+     * .then((asset) => asset.processForAllLocales())
+     * .then((asset) => console.log(asset))
+     * .catch(console.error)
+     * ```
+     */
+    processForAllLocales(options?: AssetProcessingForLocale): Promise<Asset>;
+    /**
+     * Triggers asset processing after an upload, for the file uploaded to a specific locale.
+     * @param locale - Locale which processing should be triggered for
+     * @param options - Additional options for processing
+     * @prop options.processingCheckWait - Time in milliseconds to wait before checking again if the asset has been processed (default: 500ms)
+     * @prop options.processingCheckRetries - Maximum amount of times to check if the asset has been processed (default: 5)
+     * @return Object returned from the server with updated metadata.
+     * @throws {AssetProcessingTimeout} If the asset takes too long to process. If this happens, retrieve the asset again, and if the url property is available, then processing has succeeded. If not, your file might be damaged.
+     * @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.createAssetWithId('<asset_id>', {
+     *   title: {
+     *     'en-US': 'Playsam Streamliner',
+     *   },
+     *   file: {
+     *     'en-US': {
+     *       contentType: 'image/jpeg',
+     *       fileName: 'example.jpeg',
+     *       upload: 'https://example.com/example.jpg'
+     *     }
+     *   }
+     * }))
+     * .then((asset) => asset.processForLocale('en-US'))
+     * .then((asset) => console.log(asset))
+     * .catch(console.error)
+     * ```
+     */
+    processForLocale(locale: string, Options?: AssetProcessingForLocale): Promise<Asset>;
+    /**
+     * Publishes the object
+     * @return Object returned from the server with updated metadata.
+     * @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.getAsset('<asset_id>'))
+     * .then((asset) => asset.publish())
+     * .then((asset) => console.log(`Asset ${asset.sys.id} published.`)
+     * .catch(console.error)
+     * ```
+     */
+    publish(): Promise<Asset>;
+    /**
+     * Archives the object
+     * @return Object returned from the server with updated metadata.
+     * @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.getAsset('<asset_id>'))
+     * .then((asset) => asset.archive())
+     * .then((asset) => console.log(`Asset ${asset.sys.id} archived.`)
+     * .catch(console.error)
+     * ```
+     */
+    archive(): Promise<Asset>;
+    /**
+     * 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.getAsset('<asset_id>'))
+     * .then((asset) => asset.delete())
+     * .then((asset) => console.log(`Asset deleted.`)
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * Unarchives the object
+     * @return Object returned from the server with updated metadata.
+     * @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.getAsset('<asset_id>'))
+     * .then((asset) => asset.unarchive())
+     * .then((asset) => console.log(`Asset ${asset.sys.id} unarchived.`)
+     * .catch(console.error)
+     * ```
+     */
+    unarchive(): Promise<Asset>;
+    /**
+     * Unpublishes the object
+     * @return Object returned from the server with updated metadata.
+     * @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.getAsset('<asset_id>'))
+     * .then((asset) => asset.unpublish())
+     * .then((asset) => console.log(`Asset ${asset.sys.id} unpublished.`)
+     * .catch(console.error)
+     * ```
+     */
+    unpublish(): Promise<Asset>;
+    /**
+     * 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.getAsset('<asset_id>'))
+     * .then((asset) => {
+     *   asset.fields.title['en-US'] = 'New asset title'
+     *   return asset.update()
+     * })
+     * .then((asset) => console.log(`Asset ${asset.sys.id} updated.`)
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<Asset>;
+    /**
+     * Checks if the asset is published. A published asset might have unpublished changes
+     */
+    isPublished(): boolean;
+    /**
+     * Checks if the asset is updated. This means the asset was previously published but has unpublished changes.
+     */
+    isUpdated(): boolean;
+    /**
+     * Checks if the asset is in draft mode. This means it is not published.
+     */
+    isDraft(): boolean;
+    /**
+     * Checks if asset is archived. This means it's not exposed to the Delivery/Preview APIs.
+     */
+    isArchived(): boolean;
+};
+export interface Asset extends AssetProps, DefaultElements<AssetProps>, AssetApi {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw asset data
+ * @return Wrapped asset data
+ */
+export declare function wrapAsset(makeRequest: MakeRequest, data: AssetProps): Asset;
+/**
+ * @private
+ */
+export declare const wrapAssetCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AssetProps<{}>>) => import("../common-types").Collection<Asset, AssetProps<{}>>;
+/**
+ * @private
+ */
+export declare const wrapAssetTypeCursorPaginatedCollection: (makeRequest: MakeRequest, data: CursorPaginatedCollectionProp<AssetProps<{}>>) => import("../common-types").CursorPaginatedCollection<Asset, AssetProps<{}>>;
+export {};

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

@@ -0,0 +1,102 @@
+import type { Node, Text } from '@contentful/rich-text-types';
+import type { BasicMetaSysProps, DefaultElements, GetCommentParams, GetEntryParams, GetSpaceEnvironmentParams, Link, MakeRequest, SysLink, VersionedLink } from '../common-types';
+interface LinkWithReference<T extends string> extends Link<T> {
+    sys: Link<T>['sys'] & {
+        ref: string;
+    };
+}
+export type CommentSysProps = Pick<BasicMetaSysProps, 'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'> & {
+    type: 'Comment';
+    space: SysLink;
+    environment: SysLink;
+    parentEntity: Link<'ContentType'> | LinkWithReference<'ContentType'> | Link<'Entry'> | LinkWithReference<'Entry'> | VersionedLink<'Workflow'>;
+    parent: Link<'Comment'> | null;
+};
+export type PlainTextBodyProperty = 'plain-text';
+export type RichTextBodyProperty = 'rich-text';
+export type RichTextBodyFormat = {
+    bodyFormat: RichTextBodyProperty;
+};
+export type PlainTextBodyFormat = {
+    bodyFormat?: PlainTextBodyProperty;
+};
+export type CommentStatus = 'active' | 'resolved';
+export type CommentProps = {
+    sys: CommentSysProps;
+    body: string;
+    status: CommentStatus;
+};
+export type CreateCommentProps = Omit<CommentProps, 'sys' | 'status'> & {
+    status?: CommentStatus;
+};
+export type UpdateCommentProps = Omit<CommentProps, 'sys'> & {
+    sys: Pick<CommentSysProps, 'version'>;
+};
+export declare enum CommentNode {
+    Document = "document",
+    Paragraph = "paragraph",
+    Mention = "mention"
+}
+export interface Mention {
+    nodeType: CommentNode.Mention;
+    data: {
+        target: Link<'User'> | Link<'Team'>;
+    };
+    content: Text[];
+}
+export interface RootParagraph extends Node {
+    nodeType: CommentNode.Paragraph;
+    content: (Text | Mention)[];
+}
+export interface RichTextCommentDocument extends Node {
+    nodeType: CommentNode.Document;
+    content: RootParagraph[];
+}
+export type RichTextCommentBodyPayload = {
+    body: RichTextCommentDocument;
+};
+export type RichTextCommentProps = Omit<CommentProps, 'body'> & RichTextCommentBodyPayload;
+export type GetCommentParentEntityParams = GetSpaceEnvironmentParams & ({
+    parentEntityType: 'ContentType';
+    parentEntityId: string;
+    parentEntityReference?: string;
+} | {
+    parentEntityType: 'Entry';
+    parentEntityId: string;
+    parentEntityReference?: string;
+} | {
+    parentEntityType: 'Workflow';
+    parentEntityId: string;
+    parentEntityVersion?: number;
+});
+export type GetManyCommentsParams = (GetEntryParams | GetCommentParentEntityParams) & {
+    status?: CommentStatus;
+};
+export type CreateCommentParams = (GetEntryParams | GetCommentParentEntityParams) & {
+    parentCommentId?: string;
+};
+export type UpdateCommentParams = GetCommentParams;
+export type DeleteCommentParams = GetCommentParams & {
+    version: number;
+};
+type CommentApi = {
+    update(): Promise<Comment | RichTextComment>;
+    delete(): Promise<void>;
+};
+export interface Comment extends CommentProps, DefaultElements<CommentProps>, CommentApi {
+}
+export interface RichTextComment extends Omit<CommentProps, 'body'>, RichTextCommentProps, DefaultElements<CommentProps>, CommentApi {
+}
+/**
+ * @private
+ */
+export default function createCommentApi(makeRequest: MakeRequest): CommentApi;
+/**
+ * @private
+ */
+export declare function wrapComment(makeRequest: MakeRequest, data: CommentProps | RichTextCommentProps): Comment | RichTextComment;
+/**
+ * @private
+ */
+export declare const wrapCommentCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<CommentProps | RichTextCommentProps>) => import("../common-types").Collection<Comment | RichTextComment, CommentProps | RichTextCommentProps>;
+export {};