contentful-management 11.60.3 → 12.0.0-beta.10

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

@@ -0,0 +1,273 @@
+import type { Except, JsonValue, SetOptional } from 'type-fest';
+import type { BasicMetaSysProps, CollectionProp, DefaultElements, Link, MakeRequest } from '../common-types.js';
+interface EqualityConstraint {
+    equals: [Doc, string];
+}
+interface Doc {
+    doc: 'sys.id' | 'sys.contentType.sys.id' | 'sys.environment.sys.id';
+}
+interface InConstraint {
+    in: [Doc, [string, ...string[]]];
+}
+interface RegexpConstraint {
+    regexp: [Doc, Pattern];
+}
+interface Pattern {
+    pattern: string;
+}
+interface NotConstraint {
+    not: EqualityConstraint | InConstraint | RegexpConstraint;
+}
+export type WebhookCalls = {
+    total: number;
+    healthy: number;
+};
+export type WebhookCallRequest = {
+    url: string;
+    method: string;
+    headers: {
+        [key: string]: string;
+    };
+    body: string;
+};
+export type WebhookCallResponse = WebhookCallRequest & {
+    statusCode: number;
+};
+export type WebhookHealthSys = Except<BasicMetaSysProps, 'version' | 'updatedAt' | 'updatedBy' | 'createdAt'>;
+export type WebhookCallDetailsSys = Except<BasicMetaSysProps, 'version' | 'updatedAt' | 'updatedBy'>;
+export type WebhookHeader = {
+    key: string;
+    value: string;
+    secret?: boolean;
+};
+export type WebhookFilter = EqualityConstraint | InConstraint | RegexpConstraint | NotConstraint;
+export type WebhookTransformation = {
+    method?: null | 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+    contentType?: null | 'application/vnd.contentful.management.v1+json' | 'application/vnd.contentful.management.v1+json; charset=utf-8' | 'application/json' | 'application/json; charset=utf-8' | 'application/x-www-form-urlencoded' | 'application/x-www-form-urlencoded; charset=utf-8';
+    includeContentLength?: boolean | null;
+    body?: JsonValue;
+};
+export type CreateWebhooksProps = SetOptional<Except<WebhookProps, 'sys'>, 'headers' | 'active'>;
+export type UpdateWebhookProps = SetOptional<Except<WebhookProps, 'sys'>, 'headers' | 'name' | 'topics' | 'url' | 'active'>;
+export type UpsertWebhookSigningSecretPayload = {
+    value: string;
+};
+export type WebhookCallDetailsProps = {
+    /**
+     * System metadata
+     */
+    sys: WebhookCallDetailsSys;
+    /**
+     * Request object
+     */
+    request: WebhookCallRequest;
+    /**
+     * Request object
+     */
+    response: WebhookCallResponse;
+    /**
+     * Status code of the request
+     */
+    statusCode: number;
+    /**
+     * Errors
+     */
+    errors: any[];
+    /**
+     * Type of the webhook
+     */
+    eventType: string;
+    /**
+     * Url of the request
+     */
+    url: string;
+    /**
+     * Timestamp of the request
+     */
+    requestAt: string;
+    /**
+     * Timestamp of the response
+     */
+    responseAt: string;
+};
+export type WebhookCallOverviewProps = Except<WebhookCallDetailsProps, 'request' | 'response'>;
+export type WebhookHealthProps = {
+    /**
+     * System metadata
+     */
+    sys: WebhookHealthSys & {
+        space: Link<'Space'>;
+    };
+    /**
+     * Webhook call statistics
+     */
+    calls: WebhookCalls;
+};
+export type WebhookSigningSecretSys = Except<BasicMetaSysProps, 'version'>;
+export type WebhookSigningSecretProps = {
+    sys: WebhookSigningSecretSys & {
+        space: Link<'Space'>;
+    };
+    redactedValue: string;
+};
+export type WebhookRetryPolicyPayload = {
+    maxRetries: number;
+};
+export type WebhookRetryPolicySys = Except<BasicMetaSysProps, 'version'>;
+export type WebhookRetryPolicyProps = {
+    sys: WebhookRetryPolicySys & {
+        space: Link<'Space'>;
+    };
+    maxRetries: number;
+};
+export type WebhookProps = {
+    /**
+     * System metadata
+     */
+    sys: BasicMetaSysProps & {
+        space: Link<'Space'>;
+    };
+    /**
+     * Webhook name
+     */
+    name: string;
+    /**
+     * Webhook url
+     */
+    url: string;
+    /**
+     * Topics the webhook wants to subscribe to
+     */
+    topics: string[];
+    /**
+     * Username for basic http auth
+     */
+    httpBasicUsername?: string;
+    /**
+     * Password for basic http auth
+     */
+    httpBasicPassword?: string;
+    /**
+     * Headers that should be appended to the webhook request
+     */
+    headers: Array<WebhookHeader>;
+    /**
+     * Webhook filters
+     */
+    filters?: WebhookFilter[];
+    /**
+     * Transformation to apply
+     */
+    transformation?: WebhookTransformation;
+    /**
+     * Whether the Webhook is active. If set to false, no calls will be made
+     */
+    active: boolean;
+};
+export interface WebHooks extends WebhookProps, DefaultElements<WebhookProps> {
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return 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.getWebhook('<webhook_id>'))
+     * .then((webhook) => {
+     *  webhook.name = 'new webhook name'
+     *  return webhook.update()
+     * })
+     * .then((webhook) => console.log(`webhook ${webhook.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<WebHooks>;
+    /**
+     * Deletes this object on the server.
+     * @return 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.getWebhook('<webhook_id>'))
+     * .then((webhook) => webhook.delete())
+     * .then((webhook) => console.log(`webhook ${webhook.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * List of the most recent webhook calls. See https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhook-calls/webhook-call-overviews for more details.
+     * @return Promise for list of calls
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getWebhook('<webhook_id>'))
+     * .then((webhook) => webhook.getCalls())
+     * .then((response) => console.log(response.items)) // webhook calls
+     * .catch(console.error)
+     * ```
+     */
+    getCalls(): Promise<CollectionProp<WebhookCallOverviewProps>>;
+    /**
+     * Webhook call with specific id. See https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhook-calls/webhook-call-overviews for more details
+     * @return Promise for call details
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getWebhook('<webhook_id>'))
+     * .then((webhook) => webhook.getCall('<call-id>'))
+     * .then((webhookCall) => console.log(webhookCall))
+     * .catch(console.error)
+     * ```
+     */
+    getCall(id: string): Promise<WebhookCallDetailsProps>;
+    /**
+     * Overview of the health of webhook calls. See https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhook-calls/webhook-call-overviews for more details.
+     * @return Promise for health info
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getWebhook('<webhook_id>'))
+     * .then((webhook) => webhook.getHealth())
+     * .then((webhookHealth) => console.log(webhookHealth))
+     * .catch(console.error)
+     * ```
+     */
+    getHealth(): Promise<WebhookHealthProps>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw webhook data
+ * @return Wrapped webhook data
+ */
+export declare function wrapWebhook(makeRequest: MakeRequest, data: WebhookProps): WebHooks;
+/**
+ * @private
+ */
+export declare const wrapWebhookCollection: (makeRequest: MakeRequest, data: CollectionProp<WebhookProps>) => import("../common-types.js").Collection<WebHooks, WebhookProps>;
+export {};

package/dist/types/entities/webhook.js

@@ -0,0 +1,74 @@
+import { toPlainObject, freezeSys } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils.js';
+import enhanceWithMethods from '../enhance-with-methods.js';
+
+/**
+ * @private
+ */
+function createWebhookApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        webhookDefinitionId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((data) => wrapWebhook(makeRequest, data));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+        getCalls: function getCalls() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'getManyCallDetails',
+                params: getParams(data),
+            });
+        },
+        getCall: function getCall(id) {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'getCallDetails',
+                params: { ...getParams(data), callId: id },
+            });
+        },
+        getHealth: function getHealth() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Webhook',
+                action: 'getHealthStatus',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw webhook data
+ * @return Wrapped webhook data
+ */
+function wrapWebhook(makeRequest, data) {
+    const webhook = toPlainObject(copy(data));
+    const webhookWithMethods = enhanceWithMethods(webhook, createWebhookApi(makeRequest));
+    return freezeSys(webhookWithMethods);
+}
+/**
+ * @private
+ */
+const wrapWebhookCollection = wrapCollection(wrapWebhook);
+
+export { wrapWebhook, wrapWebhookCollection };

package/dist/types/entities/workflow-definition.d.ts

@@ -0,0 +1,118 @@
+import type { BasicMetaSysProps, DefaultElements, GetSpaceEnvironmentParams, GetWorkflowDefinitionParams, Link, MakeRequest, PaginationQueryOptions } from '../common-types.js';
+type NonEmptyArray<T> = [T, ...T[]];
+export type WorkflowStepPermissionActors = 'all' | NonEmptyArray<Link<'User'> | Link<'Team'>>;
+export declare enum WorkflowStepPermissionType {
+    EntityPermission = "entity_permission",
+    WorkflowPermission = "workflow_permission"
+}
+export declare enum WorkflowStepPermissionAction {
+    Edit = "edit",
+    Publish = "publish",
+    Delete = "delete"
+}
+export declare enum WorkflowStepPermissionEffect {
+    Allow = "allow",
+    Deny = "deny"
+}
+export interface WorkflowStepPermission {
+    type: WorkflowStepPermissionType;
+    configuration: {
+        actors: WorkflowStepPermissionActors;
+        action: WorkflowStepPermissionAction;
+        effect: WorkflowStepPermissionEffect;
+    };
+}
+export declare enum WorkflowStepActionType {
+    App = "app",
+    Email = "email",
+    Task = "task"
+}
+export type WorkflowStepAction = WorkflowStepEmailAction | WorkflowStepTaskAction | WorkflowStepAppAction;
+export type WorkflowStepEmailActionRecipient = string | Link<'User'> | Link<'Team'>;
+export type WorkflowStepEmailAction = {
+    type: 'email';
+    configuration: {
+        recipients: WorkflowStepEmailActionRecipient[];
+    };
+};
+export type WorkflowStepTaskAction = {
+    type: 'task';
+    configuration: {
+        assignee: Link<'User'> | Link<'Team'>;
+        body: string;
+        dueDate?: number;
+    };
+};
+export type WorkflowStepAppAction = {
+    type: 'app';
+    appId: string;
+    appActionId: string;
+    configuration?: {
+        body?: Record<string, any>;
+        headers?: Record<string, string>;
+    };
+};
+export type WorkflowStepProps = {
+    id: string;
+    name: string;
+    description?: string;
+    actions?: WorkflowStepAction[];
+    annotations?: string[];
+    permissions?: WorkflowStepPermission[];
+};
+export type UpdateWorkflowStepProps = WorkflowStepProps;
+export type CreateWorkflowStepProps = Omit<WorkflowStepProps, 'id'>;
+export type WorkflowDefinitionSysProps = Pick<BasicMetaSysProps, 'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'> & {
+    type: 'WorkflowDefinition';
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    isLocked: boolean;
+};
+export type WorkflowDefinitionValidationLink = {
+    type: 'Link';
+    validations: Array<{
+        linkContentType: string[];
+    }>;
+    linkType: 'Entry';
+};
+export type WorkflowDefinitionProps = {
+    sys: WorkflowDefinitionSysProps;
+    name: string;
+    description?: string;
+    appliesTo?: WorkflowDefinitionValidationLink[];
+    steps: WorkflowStepProps[];
+    startOnEntityCreation?: boolean;
+    flowType?: 'no_restriction' | 'strict_neighbor';
+};
+export type CreateWorkflowDefinitionProps = Omit<WorkflowDefinitionProps, 'sys' | 'steps'> & {
+    steps: CreateWorkflowStepProps[];
+};
+export type UpdateWorkflowDefinitionProps = Omit<WorkflowDefinitionProps, 'sys' | 'steps'> & {
+    sys: Pick<WorkflowDefinitionSysProps, 'version'>;
+    steps: Array<CreateWorkflowStepProps | UpdateWorkflowStepProps>;
+};
+export type CreateWorkflowDefinitionParams = GetSpaceEnvironmentParams;
+export type UpdateWorkflowDefinitionParams = GetWorkflowDefinitionParams;
+export type DeleteWorkflowDefinitionParams = GetWorkflowDefinitionParams & {
+    version: number;
+};
+type WorkflowDefinitionApi = {
+    update(): Promise<WorkflowDefinition>;
+    delete(): Promise<void>;
+};
+export interface WorkflowDefinition extends WorkflowDefinitionProps, DefaultElements<WorkflowDefinitionProps>, WorkflowDefinitionApi {
+}
+export type WorkflowDefinitionQueryOptions = Omit<PaginationQueryOptions, 'order'>;
+/**
+ * @private
+ */
+export default function createWorkflowDefinitionApi(makeRequest: MakeRequest): WorkflowDefinitionApi;
+/**
+ * @private
+ */
+export declare function wrapWorkflowDefinition(makeRequest: MakeRequest, data: WorkflowDefinitionProps): WorkflowDefinition;
+/**
+ * @private
+ */
+export declare const wrapWorkflowDefinitionCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<WorkflowDefinitionProps>) => import("../common-types.js").Collection<WorkflowDefinition, WorkflowDefinitionProps>;
+export {};

package/dist/types/entities/workflow-definition.js

@@ -0,0 +1,28 @@
+import 'contentful-sdk-core';
+import 'fast-copy';
+
+var WorkflowStepPermissionType;
+(function (WorkflowStepPermissionType) {
+    WorkflowStepPermissionType["EntityPermission"] = "entity_permission";
+    WorkflowStepPermissionType["WorkflowPermission"] = "workflow_permission";
+})(WorkflowStepPermissionType || (WorkflowStepPermissionType = {}));
+var WorkflowStepPermissionAction;
+(function (WorkflowStepPermissionAction) {
+    WorkflowStepPermissionAction["Edit"] = "edit";
+    WorkflowStepPermissionAction["Publish"] = "publish";
+    WorkflowStepPermissionAction["Delete"] = "delete";
+})(WorkflowStepPermissionAction || (WorkflowStepPermissionAction = {}));
+var WorkflowStepPermissionEffect;
+(function (WorkflowStepPermissionEffect) {
+    WorkflowStepPermissionEffect["Allow"] = "allow";
+    WorkflowStepPermissionEffect["Deny"] = "deny";
+})(WorkflowStepPermissionEffect || (WorkflowStepPermissionEffect = {}));
+/* Workflow Step Action */
+var WorkflowStepActionType;
+(function (WorkflowStepActionType) {
+    WorkflowStepActionType["App"] = "app";
+    WorkflowStepActionType["Email"] = "email";
+    WorkflowStepActionType["Task"] = "task";
+})(WorkflowStepActionType || (WorkflowStepActionType = {}));
+
+export { WorkflowStepActionType, WorkflowStepPermissionAction, WorkflowStepPermissionEffect, WorkflowStepPermissionType };

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

@@ -0,0 +1,64 @@
+import type { BasicMetaSysProps, DefaultElements, GetSpaceEnvironmentParams, GetWorkflowParams, Link, MakeRequest, PaginationQueryOptions } from '../common-types.js';
+export type WorkflowSysProps = Pick<BasicMetaSysProps, 'id' | 'version' | 'createdAt' | 'createdBy' | 'updatedAt' | 'updatedBy'> & {
+    type: 'Workflow';
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    completedBy?: Link<'User'> | Link<'AppDefinition'>;
+    completedAt?: string;
+    deletedBy?: Link<'User'> | Link<'AppDefinition'>;
+    deletedAt?: string;
+    entity: Link<'Entry'>;
+    workflowDefinition: Link<'WorkflowDefinition'>;
+};
+export type WorkflowProps = {
+    sys: WorkflowSysProps;
+    stepId?: string;
+};
+export type CreateWorkflowProps = Omit<WorkflowProps, 'sys'> & {
+    entity: Link<'Entry'>;
+    workflowDefinition: Link<'WorkflowDefinition'>;
+};
+export type UpdateWorkflowProps = Omit<WorkflowProps, 'sys'> & {
+    sys: Pick<WorkflowSysProps, 'version'>;
+};
+export type CreateWorkflowParams = GetSpaceEnvironmentParams;
+export type UpdateWorkflowParams = GetWorkflowParams;
+export type DeleteWorkflowParams = GetWorkflowParams & {
+    version: number;
+};
+export type CompleteWorkflowParams = DeleteWorkflowParams;
+type WorkflowApi = {
+    update(): Promise<Workflow>;
+    get(): Promise<Workflow>;
+    delete(): Promise<void>;
+    complete(): Promise<void>;
+};
+type OrderQueryParam = 'sys.updatedAt' | '-sys.updatedAt' | 'sys.createdAt' | '-sys.createdAt';
+export interface Workflow extends WorkflowProps, DefaultElements<WorkflowProps>, WorkflowApi {
+}
+export type WorkflowQueryOptions = Omit<PaginationQueryOptions, 'order'> & {
+    'stepId[in]'?: string;
+    /** Find workflows filtered by the Entity type (Entry) */
+    'sys.entity.sys.linkType'?: string;
+    /** Find workflows containing the specified, comma-separated entities. Requires `sys.entity.sys.linkType` */
+    'sys.entity.sys.id[in]'?: string;
+    'sys.workflowDefinition.sys.id'?: string;
+    /**
+     * Order workflows by
+     * @default -sys.createdAt
+     * */
+    order?: OrderQueryParam;
+};
+/**
+ * @private
+ */
+export default function createWorkflowApi(makeRequest: MakeRequest): WorkflowApi;
+/**
+ * @private
+ */
+export declare function wrapWorkflow(makeRequest: MakeRequest, data: WorkflowProps): Workflow;
+/**
+ * @private
+ */
+export declare const wrapWorkflowCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<WorkflowProps>) => import("../common-types.js").Collection<Workflow, WorkflowProps>;
+export {};

package/dist/types/entities/workflows-changelog-entry.d.ts

@@ -0,0 +1,33 @@
+import type { DefaultElements, Link, MakeRequest, PaginationQueryOptions, VersionedLink } from '../common-types.js';
+export type WorkflowsChangelogQueryOptions = Omit<PaginationQueryOptions, 'order'> & {
+    /** Find workflows changelog entries filtered by the Entity type (Entry) */
+    'entity.sys.linkType': string;
+    /** Find workflows changelog entries containing the specified, comma-separated entities. Requires `sys.entity.sys.linkType` */
+    'entity.sys.id': string;
+    /** workflow.sys.id is optional so all past workflows can be found */
+    'workflow.sys.id'?: string;
+    'eventAt[lte]'?: string;
+    'eventAt[gte]'?: string;
+    'workflowDefinition.sys.id[in]'?: string;
+};
+export type WorkflowsChangelogEntryProps = {
+    event: string;
+    eventBy: Link<'User'> | Link<'AppDefinition'>;
+    eventAt: string;
+    workflow: VersionedLink<'Workflow'>;
+    workflowDefinition: Link<'WorkflowDefinition'>;
+    entity: Link<'Entry'>;
+    stepId: string;
+    stepAnnotations: string[];
+    stepName: string;
+};
+export interface WorkflowsChangelogEntry extends WorkflowsChangelogEntryProps, DefaultElements<WorkflowsChangelogEntryProps> {
+}
+/**
+ * @private
+ */
+export declare function wrapWorkflowsChangelogEntry(_makeRequest: MakeRequest, data: WorkflowsChangelogEntryProps): WorkflowsChangelogEntry;
+/**
+ * @private
+ */
+export declare const wrapWorkflowsChangelogEntryCollection: (makeRequest: MakeRequest, data: import("../common-types.js").CollectionProp<WorkflowsChangelogEntryProps>) => import("../common-types.js").Collection<WorkflowsChangelogEntry, WorkflowsChangelogEntryProps>;

package/dist/types/export-types.d.ts

@@ -0,0 +1,70 @@
+export * from './common-types.js';
+export type { AccessToken, AccessTokenProps as AccessTokenProp, CreatePersonalAccessTokenProps as CreatePATProps, } from './entities/access-token.js';
+export type { ApiKey, ApiKeyProps, CreateApiKeyProps } from './entities/api-key.js';
+export type { AppAccessToken, AppAccessTokenProps, CreateAppAccessTokenProps, } from './entities/app-access-token.js';
+export type { AiAction, AiActionProps, CreateAiActionProps } from './entities/ai-action.js';
+export type { AiActionInvocation, AiActionInvocationProps, } from './entities/ai-action-invocation.js';
+export type { AppAction, AppActionCategoryProps, AppActionCategoryType, AppActionParameterDefinition, AppActionProps, AppActionType, CreateAppActionProps, } from './entities/app-action.js';
+export type { AppActionCall, AppActionCallProps, AppActionCallErrorProps, AppActionCallRawResponseProps, AppActionCallStatus, CreateAppActionCallProps, } from './entities/app-action-call.js';
+export type { AppBundle, AppBundleFile, AppBundleProps, CreateAppBundleProps, } from './entities/app-bundle.js';
+export type { AppDefinition, AppDefinitionProps, AppLocation, CreateAppDefinitionProps, EntryFieldLocation, NavigationItem, PageLocation, SimpleLocation, } from './entities/app-definition.js';
+export type { AppDetails, AppDetailsProps, AppIcon, CreateAppDetailsProps, IconType, } from './entities/app-details.js';
+export type { AppEventSubscription, AppEventSubscriptionProps, CreateAppEventSubscriptionProps, } from './entities/app-event-subscription.js';
+export type { AppInstallation, AppInstallationProps, CreateAppInstallationProps, } from './entities/app-installation.js';
+export type { AppKey, AppKeyProps, CreateAppKeyProps } from './entities/app-key.js';
+export type { AppSignedRequest, AppSignedRequestProps, CreateAppSignedRequestProps, } from './entities/app-signed-request.js';
+export type { AppSigningSecret, AppSigningSecretProps, CreateAppSigningSecretProps, } from './entities/app-signing-secret.js';
+export type { AppUpload, AppUploadProps } from './entities/app-upload.js';
+export type { Asset, AssetFileProp, AssetProps, CreateAssetProps } from './entities/asset.js';
+export type { AssetKey, AssetKeyProps, CreateAssetKeyProps } from './entities/asset-key.js';
+export type { BulkAction, BulkActionPayload, BulkActionProps, BulkActionPublishPayload, BulkActionStatus, BulkActionType, BulkActionUnpublishPayload, BulkActionValidatePayload, } from './entities/bulk-action.js';
+export type { Comment, CommentProps, CommentStatus, CreateCommentProps, DeleteCommentParams, GetCommentParentEntityParams, GetManyCommentsParams, RichTextCommentDocument, RichTextCommentProps, UpdateCommentProps, } from './entities/comment.js';
+export type { AnnotationAssignment, ContentType, ContentTypeMetadata, ContentTypeProps, CreateContentTypeProps, } from './entities/content-type.js';
+export type { ContentFields, ContentTypeFieldValidation, ContentfulEntryResource, ExternalResource, } from './entities/content-type-fields.js';
+export type { Control, Editor, EditorInterface, EditorInterfaceProps, EditorLayoutItem, FieldGroupItem, FieldItem, GroupControl, SidebarItem, } from './entities/editor-interface.js';
+export type { CreateEntryProps, Entry, EntryProps, WithResourceName, EntryMetaSysProps, EntryReferenceProps, } from './entities/entry.js';
+export type { CreateEnvironmentProps, Environment, EnvironmentProps, } from './entities/environment.js';
+export type { CreateEnvironmentAliasProps, EnvironmentAlias, EnvironmentAliasProps, } from './entities/environment-alias.js';
+export type { ContentTypeTemplateProps, CreateEnvironmentTemplateProps, EditorInterfaceTemplateProps, EnvironmentTemplate, EnvironmentTemplateProps, Hint, } from './entities/environment-template.js';
+export type { CreateEnvironmentTemplateInstallationProps, EnvironmentTemplateInstallation, EnvironmentTemplateInstallationProps, EnvironmentTemplateInstallationStatus, EnvironmentTemplateValidationProps, ValidateEnvironmentTemplateInstallationProps, ValidationFinding, } from './entities/environment-template-installation.js';
+export type { CreateExtensionProps as CreateUIExtensionProps, Extension as UIExtension, ExtensionProps as UIExtensionProps, } from './entities/extension.js';
+export type { FieldType } from './entities/field-type.js';
+export type { FunctionProps } from './entities/function.js';
+export type { CreateLocaleProps, Locale, LocaleProps } from './entities/locale.js';
+export type { Organization, OrganizationProp, OrganizationProps } from './entities/organization.js';
+export type { OAuthApplication, OAuthApplicationProps, CreateOAuthApplicationProps, } from './entities/oauth-application.js';
+export type { CreateOrganizationInvitationProps, OrganizationInvitation, OrganizationInvitationProps, } from './entities/organization-invitation.js';
+export type { OrganizationMembership, OrganizationMembershipProps, } from './entities/organization-membership.js';
+export type { CreatePersonalAccessTokenProps, PersonalAccessToken, PersonalAccessTokenProp, PersonalAccessTokenProps, } from './entities/personal-access-token.js';
+export type { PreviewApiKey, PreviewApiKeyProps } from './entities/preview-api-key.js';
+export type { Release, ReleaseMetadata, ReleasePayload, ReleasePayloadV2, ReleaseProps, ReleaseQueryOptions, ReleaseReferenceFilters, ReleaseSysProps, ReleaseValidateOptions, } from './entities/release.js';
+export type { ReleaseAction, ReleaseActionProps, ReleaseActionQueryOptions, ReleaseActionSysProps, ReleaseActionTypes, } from './entities/release-action.js';
+export type { CreateRoleProps, Role, RoleProps, ActionType, ConstraintType, } from './entities/role.js';
+export type { ScheduledAction, ScheduledActionProps, ScheduledActionSysProps, } from './entities/scheduled-action.js';
+export type { Snapshot, SnapshotProps } from './entities/snapshot.js';
+export type { Space, SpaceProps } from './entities/space.js';
+export type { SpaceMember, SpaceMemberProps } from './entities/space-member.js';
+export type { CreateSpaceMembershipProps, SpaceMembership, SpaceMembershipProps, } from './entities/space-membership.js';
+export type { CreateTagProps, Tag, TagProps, TagVisibility, TagSysProps } from './entities/tag.js';
+export type { CreateTaskProps, Task, TaskProps, UpdateTaskProps } from './entities/task.js';
+export type { CreateTeamProps, Team, TeamProps } from './entities/team.js';
+export type { CreateTeamMembershipProps, TeamMembership, TeamMembershipProps, } from './entities/team-membership.js';
+export type { CreateTeamSpaceMembershipProps, TeamSpaceMembership, TeamSpaceMembershipProps, } from './entities/team-space-membership.js';
+export type { UIConfig, UIConfigProps } from './entities/ui-config.js';
+export type { Upload, UploadProps } from './entities/upload.js';
+export type { UploadCredential, UploadCredentialProps } from './entities/upload-credential.js';
+export type { Usage, UsageProps } from './entities/usage.js';
+export type { User, UserProps } from './entities/user.js';
+export type { UserUIConfig, UserUIConfigProps } from './entities/user-ui-config.js';
+export type { CreateWebhooksProps, UpdateWebhookProps, UpsertWebhookSigningSecretPayload, WebHooks, WebhookCallRequest, WebhookFilter, WebhookProps, WebhookSigningSecretProps, WebhookTransformation, WebhookCallDetailsProps, WebhookCallOverviewProps, WebhookHealthProps, } from './entities/webhook.js';
+export type { CreateWorkflowDefinitionParams, CreateWorkflowDefinitionProps, CreateWorkflowStepProps, DeleteWorkflowDefinitionParams, UpdateWorkflowDefinitionParams, UpdateWorkflowDefinitionProps, UpdateWorkflowStepProps, WorkflowDefinition, WorkflowDefinitionProps, WorkflowDefinitionQueryOptions, WorkflowDefinitionSysProps, WorkflowDefinitionValidationLink, WorkflowStepAction, WorkflowStepActionType, WorkflowStepAppAction, WorkflowStepEmailAction, WorkflowStepEmailActionRecipient, WorkflowStepPermission, WorkflowStepPermissionActors, WorkflowStepProps, WorkflowStepTaskAction, } from './entities/workflow-definition.js';
+export * from './plain/common-types.js';
+export { WorkflowStepPermissionAction, WorkflowStepPermissionEffect, WorkflowStepPermissionType, } from './entities/workflow-definition.js';
+export type { ConceptProps, CreateConceptProps } from './entities/concept.js';
+export type { ConceptSchemeProps, CreateConceptSchemeProps } from './entities/concept-scheme.js';
+export type { ResourceProps, ResourceQueryOptions } from './entities/resource.js';
+export type { ResourceProvider, ResourceProviderProps, UpsertResourceProviderProps, } from './entities/resource-provider.js';
+export type { ResourceType, ResourceTypeProps, SpaceEnvResourceTypeProps, UpsertResourceTypeProps, } from './entities/resource-type.js';
+export type { DefinedParameters, FreeFormParameters, InstallationParameterType, ParameterDefinition, ParameterOption, ParameterType, } from './entities/widget-parameters.js';
+export type { CreateWorkflowProps, DeleteWorkflowParams, UpdateWorkflowProps, Workflow, WorkflowProps, WorkflowQueryOptions, } from './entities/workflow.js';
+export type { WorkflowsChangelogEntry, WorkflowsChangelogEntryProps, WorkflowsChangelogQueryOptions, } from './entities/workflows-changelog-entry.js';