contentful-management 12.0.0-beta.1 → 12.0.0-beta.10

package/dist/types/adapters/REST/endpoints/app-signed-request.d.ts

@@ -1,2 +1,2 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const create: RestEndpoint<'AppSignedRequest', 'create'>;

package/dist/types/adapters/REST/endpoints/app-signed-request.js

@@ -0,0 +1,7 @@
+import { post } from './raw.js';
+
+const create = (http, params, data) => {
+    return post(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/app_installations/${params.appDefinitionId}/signed_requests`, data);
+};
+
+export { create };

package/dist/types/adapters/REST/endpoints/app-signing-secret.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'AppSigningSecret', 'get'>;
 export declare const upsert: RestEndpoint<'AppSigningSecret', 'upsert'>;
 export declare const del: RestEndpoint<'AppSigningSecret', 'delete'>;

package/dist/types/adapters/REST/endpoints/app-signing-secret.js

@@ -0,0 +1,13 @@
+import { get as get$1, put, del as del$1 } from './raw.js';
+
+const get = (http, params) => {
+    return get$1(http, `/organizations/${params.organizationId}/app_definitions/${params.appDefinitionId}/signing_secret`);
+};
+const upsert = (http, params, data) => {
+    return put(http, `/organizations/${params.organizationId}/app_definitions/${params.appDefinitionId}/signing_secret`, data);
+};
+const del = (http, params) => {
+    return del$1(http, `/organizations/${params.organizationId}/app_definitions/${params.appDefinitionId}/signing_secret`);
+};
+
+export { del, get, upsert };

package/dist/types/adapters/REST/endpoints/app-upload.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'AppUpload', 'get'>;
 export declare const del: RestEndpoint<'AppUpload', 'delete'>;
 export declare const create: RestEndpoint<'AppUpload', 'create'>;

package/dist/types/adapters/REST/endpoints/app-upload.js

@@ -0,0 +1,24 @@
+import { get as get$1, del as del$1, post } from './raw.js';
+import { getUploadHttpClient } from '../../../upload-http-client.js';
+
+const getBaseUrl = (params) => `/organizations/${params.organizationId}/app_uploads`;
+const getAppUploadUrl = (params) => `${getBaseUrl(params)}/${params.appUploadId}`;
+const get = (http, params) => {
+    const httpUpload = getUploadHttpClient(http);
+    return get$1(httpUpload, getAppUploadUrl(params));
+};
+const del = (http, params) => {
+    const httpUpload = getUploadHttpClient(http);
+    return del$1(httpUpload, getAppUploadUrl(params));
+};
+const create = (http, params, payload) => {
+    const httpUpload = getUploadHttpClient(http);
+    const { file } = payload;
+    return post(httpUpload, getBaseUrl(params), file, {
+        headers: {
+            'Content-Type': 'application/octet-stream',
+        },
+    });
+};
+
+export { create, del, get };

package/dist/types/adapters/REST/endpoints/asset-key.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare class ValidationError extends Error {
     constructor(name: string, message: string);
 }

package/dist/types/adapters/REST/endpoints/asset-key.js

@@ -0,0 +1,31 @@
+import { post } from './raw.js';
+
+const ASSET_KEY_MAX_LIFETIME = 48 * 60 * 60;
+class ValidationError extends Error {
+    constructor(name, message) {
+        super(`Invalid "${name}" provided, ` + message);
+        this.name = 'ValidationError';
+    }
+}
+const validateTimestamp = (name, timestamp, options) => {
+    options = options || {};
+    if (typeof timestamp !== 'number') {
+        throw new ValidationError(name, `only numeric values are allowed for timestamps, provided type was "${typeof timestamp}"`);
+    }
+    if (options.maximum && timestamp > options.maximum) {
+        throw new ValidationError(name, `value (${timestamp}) cannot be further in the future than expected maximum (${options.maximum})`);
+    }
+    if (options.now && timestamp < options.now) {
+        throw new ValidationError(name, `value (${timestamp}) cannot be in the past, current time was ${options.now}`);
+    }
+};
+const create = (http, params, data) => {
+    const expiresAt = data.expiresAt;
+    const now = Math.floor(Date.now() / 1000);
+    const currentMaxLifetime = now + ASSET_KEY_MAX_LIFETIME;
+    validateTimestamp('expiresAt', expiresAt, { maximum: currentMaxLifetime, now });
+    const postParams = { expiresAt };
+    return post(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/asset_keys`, postParams);
+};
+
+export { ValidationError, create };

package/dist/types/adapters/REST/endpoints/asset.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'Asset', 'get'>;
 export declare const getPublished: RestEndpoint<'Asset', 'getPublished'>;
 export declare const getMany: RestEndpoint<'Asset', 'getMany'>;

package/dist/types/adapters/REST/endpoints/asset.js

@@ -0,0 +1,207 @@
+import { errorHandler } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { getUploadHttpClient } from '../../../upload-http-client.js';
+import { get as get$2, put, del as del$1, post } from './raw.js';
+import { create as create$2 } from './upload.js';
+import { normalizeSelect } from './utils.js';
+import { get as get$1, getMany as getMany$1, update as update$1, create as create$1, createWithId as createWithId$1, createFromFiles as createFromFiles$1, processForLocale as processForLocale$1, processForAllLocales as processForAllLocales$1 } from './release-asset.js';
+
+const get = (http, params, rawData, headers) => {
+    if (params.releaseId) {
+        return get$1(http, params);
+    }
+    return get$2(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}`, {
+        params: normalizeSelect(params.query),
+        headers: headers ? { ...headers } : undefined,
+    });
+};
+const getPublished = (http, params, rawData, headers) => {
+    return get$2(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/public/assets`, {
+        params: normalizeSelect(params.query),
+        headers: headers ? { ...headers } : undefined,
+    });
+};
+const getMany = (http, params, rawData, headers) => {
+    if (params.releaseId) {
+        return getMany$1(http, params);
+    }
+    return get$2(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets`, {
+        params: normalizeSelect(params.query),
+        headers: headers ? { ...headers } : undefined,
+    });
+};
+const update = (http, params, rawData, headers) => {
+    if (params.releaseId) {
+        return update$1(http, params, rawData, headers ?? {});
+    }
+    const data = copy(rawData);
+    delete data.sys;
+    return put(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}`, data, {
+        headers: {
+            'X-Contentful-Version': rawData.sys.version ?? 0,
+            ...headers,
+        },
+    });
+};
+const del = (http, params) => {
+    return del$1(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}`);
+};
+const publish = (http, params, rawData) => {
+    const payload = params.locales?.length ? { add: { fields: { '*': params.locales } } } : null;
+    return put(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}/published`, payload, {
+        headers: {
+            'X-Contentful-Version': rawData.sys.version ?? 0,
+        },
+    });
+};
+const unpublish = (http, params, rawData) => {
+    if (params.locales?.length) {
+        const payload = { remove: { fields: { '*': params.locales } } };
+        return put(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}/published`, payload, {
+            headers: {
+                'X-Contentful-Version': rawData?.sys.version,
+            },
+        });
+    }
+    else {
+        return del$1(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}/published`);
+    }
+};
+const archive = (http, params) => {
+    return put(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}/archived`);
+};
+const unarchive = (http, params) => {
+    return del$1(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}/archived`);
+};
+const create = (http, params, rawData) => {
+    if (params.releaseId) {
+        return create$1(http, params, rawData, {});
+    }
+    const data = copy(rawData);
+    return post(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets`, data);
+};
+const createWithId = (http, params, rawData) => {
+    if (params.releaseId) {
+        return createWithId$1(http, params, rawData, {});
+    }
+    const data = copy(rawData);
+    return put(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${params.assetId}`, data);
+};
+const createFromFiles = async (http, params, data) => {
+    if (params.releaseId) {
+        return createFromFiles$1(http, params, data);
+    }
+    const httpUpload = getUploadHttpClient(http, { uploadTimeout: params.uploadTimeout });
+    const { file } = data.fields;
+    return Promise.all(Object.keys(file).map(async (locale) => {
+        const { contentType, fileName } = file[locale];
+        return create$2(httpUpload, params, file[locale]).then((upload) => {
+            return {
+                [locale]: {
+                    contentType,
+                    fileName,
+                    uploadFrom: {
+                        sys: {
+                            type: 'Link',
+                            linkType: 'Upload',
+                            id: upload.sys.id,
+                        },
+                    },
+                },
+            };
+        });
+    }))
+        .then((uploads) => {
+        const file = uploads.reduce((fieldsData, upload) => ({ ...fieldsData, ...upload }), {});
+        const asset = {
+            ...data,
+            fields: {
+                ...data.fields,
+                file,
+            },
+        };
+        return create(http, params, asset);
+    })
+        .catch(errorHandler);
+};
+/**
+ * Asset processing
+ */
+const ASSET_PROCESSING_CHECK_WAIT = 3000;
+const ASSET_PROCESSING_CHECK_RETRIES = 10;
+async function checkIfAssetHasUrl(http, params, { resolve, reject, locale, processingCheckWait = ASSET_PROCESSING_CHECK_WAIT, processingCheckRetries = ASSET_PROCESSING_CHECK_RETRIES, checkCount = 0, }) {
+    return get(http, params).then((asset) => {
+        if (asset.fields.file[locale].url) {
+            resolve(asset);
+        }
+        else if (checkCount === processingCheckRetries) {
+            const error = new Error();
+            error.name = 'AssetProcessingTimeout';
+            error.message = 'Asset is taking longer then expected to process.';
+            reject(error);
+        }
+        else {
+            checkCount++;
+            setTimeout(() => checkIfAssetHasUrl(http, params, {
+                resolve: resolve,
+                reject: reject,
+                locale: locale,
+                checkCount: checkCount,
+                processingCheckWait,
+                processingCheckRetries,
+            }), processingCheckWait);
+        }
+    });
+}
+const processForLocale = async (http, { asset, locale, options: { processingCheckRetries, processingCheckWait } = {}, ...params }) => {
+    if (asset.sys.release) {
+        return processForLocale$1(http, {
+            asset: asset,
+            locale,
+            options: { processingCheckRetries, processingCheckWait },
+            ...params,
+        });
+    }
+    return put(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/assets/${asset.sys.id}/files/${locale}/process`, null, {
+        headers: {
+            'X-Contentful-Version': asset.sys.version,
+        },
+    })
+        .then(() => {
+        return new Promise((resolve, reject) => checkIfAssetHasUrl(http, {
+            spaceId: params.spaceId,
+            environmentId: params.environmentId,
+            assetId: asset.sys.id,
+        }, {
+            resolve,
+            reject,
+            locale,
+            processingCheckWait,
+            processingCheckRetries,
+        }));
+    });
+};
+const processForAllLocales = async (http, { asset, options = {}, ...params }) => {
+    if (asset.sys.release) {
+        return processForAllLocales$1(http, {
+            asset: asset,
+            options,
+            ...params,
+        });
+    }
+    const locales = Object.keys(asset.fields.file || {});
+    let mostUpToDateAssetVersion = asset;
+    // Let all the locales process
+    // Since they all resolve at different times,
+    // we need to pick the last resolved value
+    // to reflect the most recent state
+    const allProcessingLocales = locales.map((locale) => processForLocale(http, { ...params, asset, locale, options }).then((result) => {
+        // Side effect of always setting the most up to date asset version
+        // The last one to call this will be the last one that finished
+        // and thus the most up to date
+        mostUpToDateAssetVersion = result;
+    }));
+    return Promise.all(allProcessingLocales).then(() => mostUpToDateAssetVersion);
+};
+
+export { archive, create, createFromFiles, createWithId, del, get, getMany, getPublished, processForAllLocales, processForLocale, publish, unarchive, unpublish, update };

package/dist/types/adapters/REST/endpoints/bulk-action.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'BulkAction', 'get'>;
 export declare const publish: RestEndpoint<'BulkAction', 'publish'>;
 export declare const unpublish: RestEndpoint<'BulkAction', 'unpublish'>;

package/dist/types/adapters/REST/endpoints/bulk-action.js

@@ -0,0 +1,16 @@
+import { get as get$1, post } from './raw.js';
+
+const get = (http, params) => {
+    return get$1(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/bulk_actions/actions/${params.bulkActionId}`);
+};
+const publish = (http, params, payload) => {
+    return post(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/bulk_actions/publish`, payload);
+};
+const unpublish = (http, params, payload) => {
+    return post(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/bulk_actions/unpublish`, payload);
+};
+const validate = (http, params, payload) => {
+    return post(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/bulk_actions/validate`, payload);
+};
+
+export { get, publish, unpublish, validate };

package/dist/types/adapters/REST/endpoints/comment.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'Comment', 'get'>;
 export declare const getMany: RestEndpoint<'Comment', 'getMany'>;
 export declare const create: RestEndpoint<'Comment', 'create'>;

package/dist/types/adapters/REST/endpoints/comment.js

@@ -0,0 +1,90 @@
+import copy from 'fast-copy';
+import { get as get$1, post, put, del as del$1 } from './raw.js';
+import { normalizeSelect } from './utils.js';
+
+const VERSION_HEADER = 'X-Contentful-Version';
+const BODY_FORMAT_HEADER = 'x-contentful-comment-body-format';
+const PARENT_ENTITY_REFERENCE_HEADER = 'x-contentful-parent-entity-reference';
+const PARENT_COMMENT_ID_HEADER = 'x-contentful-parent-id';
+const getSpaceEnvBaseUrl = (params) => `/spaces/${params.spaceId}/environments/${params.environmentId}`;
+const getEntityCommentUrl = (params) => `${getEntityBaseUrl(params)}/${params.commentId}`;
+function getParentPlural(parentEntityType) {
+    switch (parentEntityType) {
+        case 'ContentType':
+            return 'content_types';
+        case 'Entry':
+            return 'entries';
+        case 'Workflow':
+            return 'workflows';
+    }
+}
+/**
+ * Comments can be added to a content type, an entry, and a workflow. Workflow comments requires a version
+ * to be set as part of the URL path. Workflow comments only support `create` (with
+ * versionized URL) and `getMany` (without version). The API might support more methods
+ * in the future with new use cases being discovered.
+ */
+const getEntityBaseUrl = (paramsOrg) => {
+    const params = 'entryId' in paramsOrg
+        ? {
+            spaceId: paramsOrg.spaceId,
+            environmentId: paramsOrg.environmentId,
+            parentEntityType: 'Entry',
+            parentEntityId: paramsOrg.entryId,
+        }
+        : paramsOrg;
+    const { parentEntityId, parentEntityType } = params;
+    const parentPlural = getParentPlural(parentEntityType);
+    const versionPath = 'parentEntityVersion' in params ? `/versions/${params.parentEntityVersion}` : '';
+    return `${getSpaceEnvBaseUrl(params)}/${parentPlural}/${parentEntityId}${versionPath}/comments`;
+};
+const get = (http, params) => get$1(http, getEntityCommentUrl(params), {
+    headers: params.bodyFormat === 'rich-text'
+        ? {
+            [BODY_FORMAT_HEADER]: params.bodyFormat,
+        }
+        : {},
+});
+const getMany = (http, params) => get$1(http, getEntityBaseUrl(params), {
+    params: normalizeSelect(params.query),
+    headers: params.bodyFormat === 'rich-text'
+        ? {
+            [BODY_FORMAT_HEADER]: params.bodyFormat,
+        }
+        : {},
+});
+const create = (http, params, rawData) => {
+    const data = copy(rawData);
+    return post(http, getEntityBaseUrl(params), data, {
+        headers: {
+            ...(typeof rawData.body !== 'string' ? { [BODY_FORMAT_HEADER]: 'rich-text' } : {}),
+            ...('parentEntityReference' in params && params.parentEntityReference
+                ? { [PARENT_ENTITY_REFERENCE_HEADER]: params.parentEntityReference }
+                : {}),
+            ...(params.parentCommentId ? { [PARENT_COMMENT_ID_HEADER]: params.parentCommentId } : {}),
+        },
+    });
+};
+const update = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    delete data.sys;
+    return put(http, getEntityCommentUrl(params), data, {
+        headers: {
+            [VERSION_HEADER]: rawData.sys.version ?? 0,
+            ...(typeof rawData.body !== 'string' ? { [BODY_FORMAT_HEADER]: 'rich-text' } : {}),
+            ...headers,
+        },
+    });
+};
+const del = (http, { version, ...params }) => {
+    return del$1(http, getEntityCommentUrl(params), {
+        headers: { [VERSION_HEADER]: version },
+    });
+};
+// Add a deprecation notice. But `getAll` may never be removed for app compatibility reasons.
+/**
+ * @deprecated use `getMany` instead.
+ */
+const getAll = getMany;
+
+export { create, del, get, getAll, getMany, update };

package/dist/types/adapters/REST/endpoints/concept-scheme.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'ConceptScheme', 'get'>;
 export declare const del: RestEndpoint<'ConceptScheme', 'delete'>;
 export declare const getMany: RestEndpoint<'ConceptScheme', 'getMany'>;

package/dist/types/adapters/REST/endpoints/concept-scheme.js

@@ -0,0 +1,45 @@
+import { get as get$1, del as del$1, post, put, patch as patch$1 } from './raw.js';
+
+function basePath(orgId) {
+    return `/organizations/${orgId}/taxonomy/concept-schemes`;
+}
+const get = (http, params) => get$1(http, `${basePath(params.organizationId)}/${params.conceptSchemeId}`);
+const del = (http, params, headers) => del$1(http, `${basePath(params.organizationId)}/${params.conceptSchemeId}`, {
+    headers: {
+        'X-Contentful-Version': params.version,
+        ...headers,
+    },
+});
+const getMany = (http, params) => {
+    const url = params.query?.pageUrl ?? basePath(params.organizationId);
+    return get$1(http, url, {
+        params: params.query?.pageUrl ? undefined : params.query,
+    });
+};
+const getTotal = (http, params) => get$1(http, `${basePath(params.organizationId)}/total`);
+const create = (http, params, data) => {
+    return post(http, basePath(params.organizationId), data);
+};
+const createWithId = (http, params, data) => {
+    return put(http, `${basePath(params.organizationId)}/${params.conceptSchemeId}`, data);
+};
+const patch = (http, params, data, headers) => {
+    return patch$1(http, `${basePath(params.organizationId)}/${params.conceptSchemeId}`, data, {
+        headers: {
+            'X-Contentful-Version': params.version,
+            'Content-Type': 'application/json-patch+json',
+            ...headers,
+        },
+    });
+};
+const update = (http, params, data, headers) => {
+    return patch$1(http, `${basePath(params.organizationId)}/${params.conceptSchemeId}`, data, {
+        headers: {
+            'X-Contentful-Version': params.version,
+            'Content-Type': 'application/json-patch+json',
+            ...headers,
+        },
+    });
+};
+
+export { create, createWithId, del, get, getMany, getTotal, patch, update };

package/dist/types/adapters/REST/endpoints/concept.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const create: RestEndpoint<'Concept', 'create'>;
 export declare const createWithId: RestEndpoint<'Concept', 'createWithId'>;
 export declare const patch: RestEndpoint<'Concept', 'patch'>;

package/dist/types/adapters/REST/endpoints/concept.js

@@ -0,0 +1,61 @@
+import { post, put, patch as patch$1, get as get$1, del as del$1 } from './raw.js';
+
+function basePath(organizationId) {
+    return `/organizations/${organizationId}/taxonomy/concepts`;
+}
+const create = (http, params, data) => {
+    return post(http, basePath(params.organizationId), data);
+};
+const createWithId = (http, params, data) => {
+    return put(http, `${basePath(params.organizationId)}/${params.conceptId}`, data);
+};
+const patch = (http, params, data, headers) => {
+    return patch$1(http, `${basePath(params.organizationId)}/${params.conceptId}`, data, {
+        headers: {
+            'X-Contentful-Version': params.version,
+            'Content-Type': 'application/json-patch+json',
+            ...headers,
+        },
+    });
+};
+const update = (http, params, data, headers) => {
+    return patch$1(http, `${basePath(params.organizationId)}/${params.conceptId}`, data, {
+        headers: {
+            'X-Contentful-Version': params.version,
+            'Content-Type': 'application/json-patch+json',
+            ...headers,
+        },
+    });
+};
+const get = (http, params) => get$1(http, `${basePath(params.organizationId)}/${params.conceptId}`);
+const del = (http, params, headers) => del$1(http, `${basePath(params.organizationId)}/${params.conceptId}`, {
+    headers: {
+        'X-Contentful-Version': params.version ?? 0,
+        ...headers,
+    },
+});
+const getMany = (http, params) => {
+    const { url, queryParams } = cursorBasedCollection('', params);
+    return get$1(http, url, {
+        params: queryParams,
+    });
+};
+const getDescendants = (http, params) => {
+    const { url, queryParams } = cursorBasedCollection(`/${params.conceptId}/descendants`, params);
+    return get$1(http, url, { params: queryParams });
+};
+const getAncestors = (http, params) => {
+    const { url, queryParams } = cursorBasedCollection(`/${params.conceptId}/ancestors`, params);
+    return get$1(http, url, { params: queryParams });
+};
+const getTotal = (http, params) => get$1(http, `${basePath(params.organizationId)}/total`);
+function cursorBasedCollection(path, params) {
+    return params.query?.pageUrl
+        ? { url: params.query?.pageUrl }
+        : {
+            url: `${basePath(params.organizationId)}${path}`,
+            queryParams: params.query,
+        };
+}
+
+export { create, createWithId, del, get, getAncestors, getDescendants, getMany, getTotal, patch, update };

package/dist/types/adapters/REST/endpoints/content-type.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'ContentType', 'get'>;
 export declare const getMany: RestEndpoint<'ContentType', 'getMany'>;
 export declare const create: RestEndpoint<'ContentType', 'create'>;

package/dist/types/adapters/REST/endpoints/content-type.js

@@ -0,0 +1,52 @@
+import copy from 'fast-copy';
+import { get as get$1, post, put, del as del$1 } from './raw.js';
+import { normalizeSelect } from './utils.js';
+
+const getBaseUrl = (params) => `/spaces/${params.spaceId}/environments/${params.environmentId}/content_types`;
+const getContentTypeUrl = (params) => getBaseUrl(params) + `/${params.contentTypeId}`;
+const get = (http, params, headers) => {
+    return get$1(http, getContentTypeUrl(params), {
+        params: normalizeSelect(params.query),
+        headers,
+    });
+};
+const getMany = (http, params, headers) => {
+    return get$1(http, getBaseUrl(params), {
+        params: params.query,
+        headers,
+    });
+};
+const create = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    return post(http, getBaseUrl(params), data, { headers });
+};
+const createWithId = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    return put(http, getContentTypeUrl(params), data, { headers });
+};
+const update = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    delete data.sys;
+    return put(http, getContentTypeUrl(params), data, {
+        headers: {
+            'X-Contentful-Version': rawData.sys.version ?? 0,
+            ...headers,
+        },
+    });
+};
+const del = (http, params, headers) => {
+    return del$1(http, getContentTypeUrl(params), { headers });
+};
+const publish = (http, params, rawData, headers) => {
+    return put(http, getContentTypeUrl(params) + '/published', null, {
+        headers: {
+            'X-Contentful-Version': rawData.sys.version,
+            ...headers,
+        },
+    });
+};
+const unpublish = (http, params, headers) => {
+    return del$1(http, getContentTypeUrl(params) + '/published', { headers });
+};
+
+export { create, createWithId, del, get, getMany, publish, unpublish, update };

package/dist/types/adapters/REST/endpoints/editor-interface.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'EditorInterface', 'get'>;
 export declare const getMany: RestEndpoint<'EditorInterface', 'getMany'>;
 export declare const update: RestEndpoint<'EditorInterface', 'update'>;

package/dist/types/adapters/REST/endpoints/editor-interface.js

@@ -0,0 +1,22 @@
+import copy from 'fast-copy';
+import { get as get$1, put } from './raw.js';
+
+const getBaseUrl = (params) => `/spaces/${params.spaceId}/environments/${params.environmentId}/content_types/${params.contentTypeId}/editor_interface`;
+const get = (http, params) => {
+    return get$1(http, getBaseUrl(params));
+};
+const getMany = (http, params) => {
+    return get$1(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/editor_interfaces`);
+};
+const update = (http, params, rawData, headers) => {
+    const data = copy(rawData);
+    delete data.sys;
+    return put(http, getBaseUrl(params), data, {
+        headers: {
+            'X-Contentful-Version': rawData.sys.version ?? 0,
+            ...headers,
+        },
+    });
+};
+
+export { get, getMany, update };

package/dist/types/adapters/REST/endpoints/entry.d.ts

@@ -1,4 +1,4 @@
-import type { RestEndpoint } from '../types';
+import type { RestEndpoint } from '../types.js';
 export declare const get: RestEndpoint<'Entry', 'get'>;
 export declare const getPublished: RestEndpoint<'Entry', 'getPublished'>;
 export declare const getMany: RestEndpoint<'Entry', 'getMany'>;