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

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

@@ -0,0 +1,103 @@
+import type { FieldType } from './field-type';
+import type { DefinedParameters, InstallationParameterType, ParameterDefinition } from './widget-parameters';
+import type { DefaultElements, BasicMetaSysProps, SysLink, MakeRequest } from '../common-types';
+import type { SetRequired, RequireExactlyOne } from 'type-fest';
+type ExtensionSysProps = BasicMetaSysProps & {
+    space: SysLink;
+    environment: SysLink;
+    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").CollectionProp<ExtensionProps>) => import("../common-types").Collection<Extension, ExtensionProps>;
+export {};

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

@@ -0,0 +1,46 @@
+import type { Link, DefaultElements } from '../common-types';
+import type { MakeRequest } from '../common-types';
+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").CollectionProp<FunctionLogProps>) => import("../common-types").Collection<FunctionLogProps, FunctionLogProps>;

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

@@ -0,0 +1,32 @@
+import type { Link, DefaultElements } from '../common-types';
+import type { MakeRequest } from '../common-types';
+export type FunctionProps = {
+    sys: {
+        id: string;
+        type: 'Function';
+        createdBy: Link<'User'>;
+        createdAt: string;
+        updatedBy: Link<'User'>;
+        updatedAt: string;
+        organization: Link<'Organization'>;
+        appDefinition: Link<'AppDefinition'>;
+    };
+    name: string;
+    description: string;
+    path: string;
+    accepts: string[];
+    allowNetworks?: string[];
+};
+export interface Function extends FunctionProps, DefaultElements<FunctionProps> {
+}
+/**
+ * @private
+ * @param makeRequest - (real) function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+export declare function wrapFunction(makeRequest: MakeRequest, data: FunctionProps): FunctionProps;
+/**
+ * @private
+ */
+export declare const wrapFunctionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<FunctionProps>) => import("../common-types").Collection<FunctionProps, FunctionProps>;

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

@@ -0,0 +1,95 @@
+import type { Except, SetOptional } from 'type-fest';
+import type { BasicMetaSysProps, SysLink, DefaultElements, MakeRequest } from '../common-types';
+export type LocaleProps = {
+    sys: BasicMetaSysProps & {
+        space: SysLink;
+        environment: SysLink;
+    };
+    /**
+     * Locale name
+     */
+    name: string;
+    /**
+     * Locale code (example: en-us)
+     */
+    code: string;
+    /**
+     * Internal locale code
+     */
+    internal_code: string;
+    /**
+     * Locale code to fallback to when there is not content for the current locale
+     */
+    fallbackCode: string | null;
+    /**
+     *  If the content under this locale should be available on the CDA (for public reading)
+     */
+    contentDeliveryApi: boolean;
+    /**
+     * If the content under this locale should be available on the CMA (for editing)
+     */
+    contentManagementApi: boolean;
+    /**
+     * If this is the default locale
+     */
+    default: boolean;
+    /**
+     * If the locale needs to be filled in on entries or not
+     */
+    optional: boolean;
+};
+export type CreateLocaleProps = Omit<SetOptional<Except<LocaleProps, 'sys'>, 'optional' | 'contentManagementApi' | 'default' | 'contentDeliveryApi'>, 'internal_code'>;
+export interface Locale extends LocaleProps, DefaultElements<LocaleProps> {
+    /**
+     * 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.getLocale('<locale_id>'))
+     * .then((locale) => locale.delete())
+     * .then(() => console.log(`locale deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * 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.getLocale('<locale_id>'))
+     * .then((locale) => {
+     *   locale.name = 'New locale name'
+     *   return locale.update()
+     * })
+     * .then((locale) => console.log(`locale ${locale.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<Locale>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw locale data
+ * @return Wrapped locale data
+ */
+export declare function wrapLocale(makeRequest: MakeRequest, data: LocaleProps): Locale;
+/**
+ * @private
+ */
+export declare const wrapLocaleCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<LocaleProps>) => import("../common-types").Collection<Locale, LocaleProps>;

package/dist/typings/entities/oauth-application.d.ts

@@ -0,0 +1,56 @@
+import type { BasicMetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+type OAuthApplicationSysProps = BasicMetaSysProps & {
+    lastUsedAt: string | null;
+};
+export declare enum ScopeValues {
+    Read = "content_management_read",
+    Manage = "content_management_manage"
+}
+export type OAuthApplicationProps = {
+    name: string;
+    description: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    scopes: ScopeValues[];
+    confidential: boolean;
+    sys: OAuthApplicationSysProps;
+};
+export type CreateOAuthApplicationProps = {
+    name: string;
+    description: string;
+    redirectUri: string;
+    scopes: ScopeValues[];
+    confidential: boolean;
+};
+export type UpdateOAuthApplicationProps = {
+    name?: string;
+    description?: string;
+    redirectUri?: string;
+    scopes?: ScopeValues[];
+    confidential?: boolean;
+};
+export interface OAuthApplication extends OAuthApplicationProps, DefaultElements<OAuthApplicationProps> {
+    /**
+     * Deletes an OAuth application
+     * @return Promise for the deleted OAuth application
+     */
+    delete(): Promise<void>;
+    /**
+     * Updates an OAuth application
+     * @return Promise for the updated OAuth application
+     */
+    update(): Promise<OAuthApplicationProps>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw OAuth application data
+ * @return Wrapped OAuth application data
+ */
+export declare function wrapOAuthApplication(makeRequest: MakeRequest, data: OAuthApplicationProps, userId: string): OAuthApplication;
+/**
+ * @private
+ */
+export declare const wrapOAuthApplicationCollection: (makeRequest: MakeRequest, data: import("../common-types").CursorPaginatedCollectionProp<OAuthApplicationProps>, userId: string) => import("../common-types").CursorPaginatedCollection<OAuthApplication, OAuthApplicationProps>;
+export {};

package/dist/typings/entities/organization-membership.d.ts

@@ -0,0 +1,69 @@
+import type { MetaSysProps, DefaultElements, MetaLinkProps, MakeRequest } from '../common-types';
+export type OrganizationMembershipProps = {
+    /**
+     * System metadata
+     */
+    sys: MetaSysProps & {
+        user: {
+            sys: MetaLinkProps;
+        };
+    };
+    /**
+     * Role
+     */
+    role: string;
+    /**
+     * status
+     */
+    status: boolean;
+};
+export interface OrganizationMembership extends OrganizationMembershipProps, DefaultElements<OrganizationMembershipProps> {
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('organization_id')
+     * .then(org => org.getOrganizationMembership('organizationMembership_id'))
+     * .then((organizationMembership) => {
+     *  organizationMembership.role = 'member';
+     *  organizationMembership.update();
+     * })
+     * .catch(console.error)
+     */
+    update(): Promise<OrganizationMembership>;
+    /**
+     * Deletes this object on the server.
+     * @example```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getOrganization('organization_id')
+     * .then(org => org.getOrganizationMembership('organizationMembership_id'))
+     * .then((organizationMembership) => {
+     *  organizationMembership.delete();
+     * })
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param {function} makeRequest - function to make requests via an adapter
+ * @param {Object} data - Raw organization membership data
+ * @return {OrganizationMembership} Wrapped organization membership data
+ */
+export declare function wrapOrganizationMembership(makeRequest: MakeRequest, data: OrganizationMembershipProps, organizationId: string): OrganizationMembership;
+/**
+ * @private
+ */
+export declare const wrapOrganizationMembershipCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<OrganizationMembershipProps>, organizationId: string) => import("../common-types").Collection<OrganizationMembership, OrganizationMembershipProps>;

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

@@ -0,0 +1,33 @@
+import type { ContentfulOrganizationAPI } from '../create-organization-api';
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+export type Organization = DefaultElements<OrganizationProps> & OrganizationProps & ContentfulOrganizationAPI;
+export type OrganizationProps = {
+    /**
+     * System metadata
+     */
+    sys: MetaSysProps;
+    /**
+     * Name
+     */
+    name: string;
+};
+/**
+ * @deprecated Use `OrganizationProps` instead.
+ */
+export type OrganizationProp = OrganizationProps;
+/**
+ * This method creates the API for the given organization with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with an organization id, so the base path for requests now has the
+ * organization id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for an Organization
+ * @return {Organization}
+ */
+export declare function wrapOrganization(makeRequest: MakeRequest, data: OrganizationProps): Organization;
+/**
+ * This method normalizes each organization in a collection.
+ * @private
+ */
+export declare const wrapOrganizationCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<OrganizationProps>) => import("../common-types").Collection<Organization, OrganizationProps>;

package/dist/typings/entities/personal-access-token.d.ts

@@ -0,0 +1,51 @@
+import type { MetaSysProps, DefaultElements, MakeRequest } from '../common-types';
+export type PersonalAccessTokenProps = {
+    sys: MetaSysProps & {
+        expiresAt?: string;
+    };
+    name: string;
+    scopes: 'content_management_manage'[];
+    revokedAt: null | string;
+    token?: string;
+};
+/**
+ * @deprecated Use `PersonalAccessTokenProps` instead.
+ */
+export type PersonalAccessTokenProp = PersonalAccessTokenProps;
+export type CreatePersonalAccessTokenProps = Pick<PersonalAccessToken, 'name' | 'scopes'> & {
+    expiresIn?: number;
+};
+export interface PersonalAccessToken extends PersonalAccessTokenProps, DefaultElements<PersonalAccessTokenProps> {
+    /**
+     * Revokes a personal access token
+     * @return Object the revoked personal access token
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *  accessToken: <content_management_api_key>
+     * })
+     *
+     * client.getPersonalAccessToken('<token-id>')
+     *  .then((personalAccessToken) => {
+     *    return personalAccessToken.revoke()
+     *  })
+     *  .catch(console.error)
+     * ```
+     */
+    revoke(): Promise<PersonalAccessToken>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw  personal access token data
+ * @return Wrapped personal access token
+ */
+export declare function wrapPersonalAccessToken(makeRequest: MakeRequest, data: PersonalAccessTokenProps): PersonalAccessToken;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw personal access collection data
+ * @return Wrapped personal access token collection data
+ */
+export declare const wrapPersonalAccessTokenCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<PersonalAccessTokenProps>) => import("../common-types").Collection<PersonalAccessToken, PersonalAccessTokenProps>;

package/dist/typings/entities/preview-api-key.d.ts

@@ -0,0 +1,20 @@
+import type { DefaultElements, MakeRequest, MetaSysProps } from '../common-types';
+export type PreviewApiKeyProps = {
+    sys: MetaSysProps;
+    name: string;
+    description: string;
+    accessToken: string;
+};
+export interface PreviewApiKey extends PreviewApiKeyProps, DefaultElements<PreviewApiKeyProps> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw api key data
+ * @return Wrapped preview api key data
+ */
+export declare function wrapPreviewApiKey(_makeRequest: MakeRequest, data: PreviewApiKeyProps): PreviewApiKey;
+/**
+ * @private
+ */
+export declare const wrapPreviewApiKeyCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<PreviewApiKeyProps>) => import("../common-types").Collection<PreviewApiKey, PreviewApiKeyProps>;

package/dist/typings/entities/release-action.d.ts

@@ -0,0 +1,58 @@
+import type { DefaultElements, ISO8601Timestamp, Link, MakeRequest } from '../common-types';
+import type { AsyncActionProcessingOptions } from '../methods/action';
+type ReleaseActionStatuses = 'created' | 'inProgress' | 'failed' | 'succeeded';
+export type ReleaseActionTypes = 'publish' | 'unpublish' | 'validate';
+export type ReleaseActionSysProps = {
+    id: string;
+    type: 'ReleaseAction';
+    space: Link<'Space'>;
+    environment: Link<'Environment'>;
+    release: Link<'Release'>;
+    status: ReleaseActionStatuses;
+    createdBy: Link<'User'>;
+    createdAt: ISO8601Timestamp;
+    updatedBy: Link<'User'>;
+    updatedAt: ISO8601Timestamp;
+};
+/** The object returned by the Releases API */
+export interface ReleaseActionProps<T extends ReleaseActionTypes = any> {
+    action: T;
+    sys: ReleaseActionSysProps;
+}
+export interface ReleaseActionQueryOptions {
+    /** Find Release Actions by using a comma-separated list of Ids */
+    'sys.id[in]'?: string;
+    'sys.release.sys.id[in]'?: string;
+    'sys.status[in]'?: string;
+    'sys.status[nin]'?: string;
+    action?: ReleaseActionTypes;
+    /** Get unique results by this field. Currently supports `sys.release.sys.id` */
+    uniqueBy?: string;
+    /** @default -sys.updatedAt */
+    order?: string;
+    /**
+     * Limit of how many records are returned in the query result
+     * @default 100
+     * */
+    limit?: number;
+}
+export interface ReleaseActionApiMethods {
+    /** Performs a new GET request and returns the wrapper Release */
+    get(): ReleaseAction;
+    /** Waits until the Release Action has either succeeded or failed */
+    waitProcessing(options?: AsyncActionProcessingOptions): ReleaseAction;
+}
+export interface ReleaseAction<T extends ReleaseActionTypes = any> extends ReleaseActionProps<T>, ReleaseActionApiMethods, DefaultElements<ReleaseActionProps<T>> {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw Release data
+ * @return Wrapped Release data
+ */
+export declare function wrapReleaseAction(makeRequest: MakeRequest, data: ReleaseActionProps): ReleaseAction;
+/**
+ * @private
+ */
+export declare const wrapReleaseActionCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<ReleaseActionProps<any>>) => import("../common-types").Collection<ReleaseAction<any>, ReleaseActionProps<any>>;
+export {};

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

@@ -0,0 +1,85 @@
+import type { DefaultElements, BasicMetaSysProps, SysLink, MakeRequest } from '../common-types';
+export type ActionType = 'read' | 'create' | 'update' | 'delete' | 'publish' | 'unpublish' | 'archive' | 'unarchive';
+type ConditionType = 'and' | 'or' | 'not' | 'equals';
+export type ConstraintType = {
+    [key in ConditionType]?: ConstraintType[] | any;
+};
+export type RoleProps = {
+    sys: BasicMetaSysProps & {
+        space: SysLink;
+    };
+    name: string;
+    description?: string;
+    /**
+     * Permissions for application sections
+     */
+    permissions: {
+        ContentDelivery: string[] | string;
+        ContentModel: string[];
+        EnvironmentAliases: string[] | string;
+        Environments: string[] | string;
+        Settings: string[] | string;
+        Tags: string[] | string;
+    };
+    policies: {
+        effect: string;
+        actions: ActionType[] | 'all';
+        constraint: ConstraintType;
+    }[];
+};
+export type CreateRoleProps = Omit<RoleProps, 'sys'>;
+export interface Role extends RoleProps, DefaultElements<RoleProps> {
+    /**
+     * Deletes this object on the server.
+     * @memberof Role
+     * @func delete
+     * @return {Promise} 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.getRole('<role_id>'))
+     * .then((role) => role.delete())
+     * .then((role) => console.log(`role deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * 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.getRole('<roles_id>'))
+     * .then((roles) => {
+     *   roles.name = 'New role name'
+     *   return roles.update()
+     * })
+     * .then((roles) => console.log(`roles ${roles.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<Role>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw role data
+ * @return Wrapped role data
+ */
+export declare function wrapRole(makeRequest: MakeRequest, data: RoleProps): Role;
+/**
+ * @private
+ */
+export declare const wrapRoleCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<RoleProps>) => import("../common-types").Collection<Role, RoleProps>;
+export {};