contentful-management 12.0.0-new-beta.3 → 12.0.0-new-beta.5

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

@@ -0,0 +1,157 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { CollectionProp, GetExtensionParams, GetSpaceEnvironmentParams, QueryParams } from '../../common-types';
+import type { CreateExtensionProps, ExtensionProps } from '../../entities/extension';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type ExtensionPlainClientAPI = {
+    /**
+     * Fetches the Extension
+     * @param params entity IDs to identify the Extension
+     * @returns the Extension and its metadata
+     * @throws if the request fails, or the Extension is not found
+     * @example
+     * ```javascript
+     * const uiExtension = await client.extension.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   extensionId: '<extension_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetExtensionParams & QueryParams>): Promise<ExtensionProps>;
+    /**
+     * Fetches all Extensions of a Space/Environment
+     * @param params entity IDs to identify the Space/Environment from which to fetch Extensions
+     * @returns an object containing the array of Extensions
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * const results = await client.extension.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<ExtensionProps>>;
+    /**
+     * Creates a new Extension with an auto-generated ID
+     * @param params entity IDs to identify the Environment in which to create the Extension
+     * @param rawData the Extension
+     * @returns the created Extension and its metadata
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * const rawData = {
+     *   extension: {
+     *     name: 'My extension',
+     *     src: 'https://www.example.com',
+     *     fieldTypes: [
+     *       {
+     *         type: 'Symbol',
+     *       },
+     *     ],
+     *     sidebar: false,
+     *   }
+     * };
+     * const uiExtension = await client.extension.create(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *   },
+     *   rawData
+     * );
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateExtensionProps, headers?: RawAxiosRequestHeaders): Promise<ExtensionProps>;
+    /**
+     * Creates a new Extension with a given ID
+     * @param params entity IDs to identify the Environment in which to create the Extension
+     * @param rawData the Extension
+     * @returns the created Extension and its metadata
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * const rawData = {
+     *   extension: {
+     *     name: 'My extension',
+     *     src: 'https://www.example.com',
+     *     fieldTypes: [
+     *       {
+     *         type: 'Symbol',
+     *       },
+     *     ],
+     *     sidebar: false,
+     *   }
+     * };
+     * const uiExtension = await client.extension.createWithId(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *     extensionId: '<extension_id>',
+     *   },
+     *   rawData
+     * );
+     * ```
+     */
+    createWithId(params: OptionalDefaults<GetExtensionParams>, rawData: CreateExtensionProps, headers?: RawAxiosRequestHeaders): Promise<ExtensionProps>;
+    /**
+     * Updates an Extension
+     * @param params entity IDs to identify the Extension
+     * @param rawData the Extension update
+     * @param headers when updating an existing Extension, use the 'X-Contentful-Version' header to specify the last version of the Extension you are updating
+     * @returns the updated Extension and its metadata
+     * @throws if the request fails, or the Space/Environment is not found
+     * @example
+     * ```javascript
+     * // Create Extension
+     * let uiExtension = await client.extension.create(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *   },
+     *   {
+     *     extension: {
+     *       name: 'My extension',
+     *       src: 'https://www.example.com',
+     *       fieldTypes: [
+     *         {
+     *           type: 'Symbol',
+     *         },
+     *       ],
+     *       sidebar: false,
+     *     },
+     *   }
+     * );
+     *
+     * // Update Extension
+     * uiExtension = await client.extension.update(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *     extensionId: '<extension_id>',
+     *   },
+     *   {
+     *     sys: uiExtension.sys,
+     *     extension: {
+     *       ...uiExtension.extension,
+     *       name: 'Even more awesome extension',
+     *     },
+     *   }
+     * );
+     * ```
+     */
+    update(params: OptionalDefaults<GetExtensionParams>, rawData: ExtensionProps, headers?: RawAxiosRequestHeaders): Promise<ExtensionProps>;
+    /**
+     * Deletes the Extension
+     * @param params entity IDs to identity the Extension
+     * @throws if the request fails, or the Extension is not found
+     * @example
+     * ```javascript
+     * await client.extension.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   extensionId: '<extension_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetExtensionParams>): Promise<any>;
+};

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

@@ -0,0 +1,51 @@
+import type { CollectionProp, GetFunctionLogParams, GetManyFunctionLogParams } from '../../common-types';
+import type { FunctionLogProps } from '../../entities/function-log';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type FunctionLogPlainClientAPI = {
+    /**
+     * Fetches the specified FunctionLog
+     * @params spaceId, environmentId, appInstallationId, functionId, logId
+     * @returns the FunctionLog
+     * @throws if the request fails, or the FunctionLog is not found
+     * @example
+     * ```javascript
+     * const functionLog = await client.functionLog.get({
+     *    spaceId: '<space_id>',
+     *    environmentId: '<environment_id>',
+     *    appInstallationId: '<app_installation_id>',
+     *    functionId: '<function_id>',
+     *    logId: '<log_id>'
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetFunctionLogParams>): Promise<FunctionLogProps>;
+    /**
+     * Fetches all FunctionLogs for the given function
+     * @params spaceId, environmentId, appInstallationId, functionId, query
+     * @returns an object containing an array of FunctionLogs
+     * @throws if the request fails, or the FunctionLogs are not found
+     * @example
+     * ```javascript
+     * const start = new Date()
+     * const end = new Date()
+     * start.setHours(start.getHours() - 1)
+     *
+     * const functionLogs = await client.functionLog.getMany({
+     *    spaceId: '<space_id>',
+     *    environmentId: '<environment_id>',
+     *    appInstallationId: '<app_installation_id>',
+     *    functionId: '<function_id>',
+     *    query: {
+     *      // optional limit
+     *      limit: 10,
+     *      // optional interval query
+     *      'sys.createdAt[gte]': start,
+     *      'sys.createdAt[lt]': end,
+     *      // optional cursor based pagination parameters
+     *      pageNext: '<page_next>',
+     *    }
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetManyFunctionLogParams>): Promise<CollectionProp<FunctionLogProps>>;
+};

package/dist/types/plain/entities/function.d.ts

@@ -0,0 +1,51 @@
+import type { CollectionProp, GetFunctionParams, GetFunctionForEnvParams, GetManyFunctionParams } from '../../common-types';
+import type { FunctionProps } from '../../entities/function';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type FunctionPlainClientAPI = {
+    /**
+     * Fetches the specified Function
+     * @params organizationId, appDefinitionId, functionId
+     * @returns the Function
+     * @throws if the request fails, or the Function is not found
+     * @example
+     * ```javascript
+     * const func = await client.function.get({
+     *   organizationId: "<org_id>",
+     *   appDefinitionId: "<app_definition_id>",
+     *   functionId: "<function_id>",
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetFunctionParams>): Promise<FunctionProps>;
+    /**
+     * Fetches all Functions for the given app
+     * @params organizationId, appDefinitionId, query
+     * @returns an object containing an array of Functions
+     * @throws if the request fails, or the App is not found
+     * @example
+     * ```javascript
+     * const functions = await client.function.getMany({
+     *   organizationId: "<org_id>",
+     *   appDefinitionId: "<app_definition_id>",
+     *   query: { 'accepts[all]': '<action>' },
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetManyFunctionParams>): Promise<CollectionProp<FunctionProps>>;
+    /**
+     * Fetches all Functions for the given environment
+     * @params spaceId, environmentId, appInstallationId, query
+     * @returns an object containing an array of Functions
+     * @throws if the request fails, or the Environment is not found
+     * @example
+     * ```javascript
+     * const functions = await client.function.getManyForEnvironment({
+     *   spaceId: "<space_id>",
+     *   environmentId: "<environment_id>",
+     *   appInstallationId: "<app_installation_id>",
+     *   query: { 'accepts[all]': '<action>' },
+     * });
+     * ```
+     */
+    getManyForEnvironment(params: OptionalDefaults<GetFunctionForEnvParams>): Promise<CollectionProp<FunctionProps>>;
+};

package/dist/types/plain/entities/locale.d.ts

@@ -0,0 +1,112 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { GetSpaceEnvironmentParams, QueryParams, CollectionProp } from '../../common-types';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { CreateLocaleProps, LocaleProps } from '../../entities/locale';
+export type LocalePlainClientAPI = {
+    /**
+     * Fetch a single locale by ID
+     * @param params the locale ID and the IDs of the space and environment
+     * @returns the locale
+     * @throws if the space, environment, or locale are not found
+     * @example
+     * ```javascript
+     * const locale = await client.locale.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   localeId: 'en-US',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        localeId: string;
+    }>): Promise<LocaleProps>;
+    /**
+     * Fetch all locales in a space and environment
+     * @param params the space and environment IDs
+     * @returns a collection of locales
+     * @throws if the space or environment are not found
+     * @example
+     * ```javascript
+     * const locales = await client.locale.getMany(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *     query: {
+     *       limit: 10,
+     *     },
+     *   }
+     * );
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<LocaleProps>>;
+    /**
+     * Delete a locale
+     * @param params the space, environment, and locale IDs
+     * @returns void
+     * @throws if the space, environment, or locale are not found
+     * @example
+     * ```javascript
+     * await client.locale.delete({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   localeId: 'en-US',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        localeId: string;
+    }>): Promise<any>;
+    /**
+     * Update a locale
+     * @param params the space, environment, and locale IDs
+     * @param rawData the updated locale data
+     * @returns the updated locale
+     * @throws if the space, environment, or locale are not found
+     * @example
+     * ```javascript
+     * let locale = await client.locale.get({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   localeId: 'en-US',
+     * });
+     *
+     * locale = await client.locale.update(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *     localeId: 'en-US',
+     *   },
+     *   {
+     *     ...locale,
+     *     name: 'English (US)',
+     *   }
+     * );
+     * ```
+     */
+    update(params: OptionalDefaults<GetSpaceEnvironmentParams & {
+        localeId: string;
+    }>, rawData: LocaleProps, headers?: RawAxiosRequestHeaders): Promise<LocaleProps>;
+    /**
+     * Create a locale
+     * @param params the space and environment ID to create the locale in
+     * @param data the locale data
+     * @returns the created locale
+     * @throws if the space or environment are not found or the payload is malformed
+     * @example
+     * ```javascript
+     * const locale = await client.locale.create(
+     *   {
+     *     spaceId: '<space_id>',
+     *     environmentId: '<environment_id>',
+     *   },
+     *   {
+     *     name: 'German (Austria)',
+     *     code: 'de-AT',
+     *     fallbackCode: 'de-DE',
+     *     optional: true,
+     *   }
+     * );
+     * ```
+     */
+    create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateLocaleProps, headers?: RawAxiosRequestHeaders): Promise<LocaleProps>;
+};

package/dist/types/plain/entities/oauth-application.d.ts

@@ -0,0 +1,90 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { GetOAuthApplicationParams, QueryParams, CursorPaginatedCollectionProp, GetUserParams } from '../../common-types';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { CreateOAuthApplicationProps, OAuthApplicationProps, UpdateOAuthApplicationProps } from '../../entities/oauth-application';
+export type OAuthApplicationPlainClientAPI = {
+    /**
+     * Retrieves a list of OAuth applications associated with the current user.
+     * @param userId the user ID
+     * @returns A collection of oauth applications
+     * @throws if the request fails, or the user is not found
+     * @example
+     * ```javascript
+     * const oauthApplication = await client.oauthApplication.getManyForUser({
+     *  userId: '<user_id>',
+     *   query: {
+     *     limit: 10,
+     *   }
+     * })
+     * ```
+     */
+    getManyForUser(params: OptionalDefaults<GetUserParams & QueryParams>): Promise<CursorPaginatedCollectionProp<OAuthApplicationProps>>;
+    /**
+     * Retrieves details of a specific OAuth application.
+     * @param userId the user ID
+     * @param oauthApplicationId the OAuth application ID
+     * @returns the requested OAuth Application
+     * @throws if the request fails, or the OAuth Application or user are not found
+     * @example
+     * ```javascript
+     * const oauthApplication = await client.oauthApplication.get({
+     *   userId: '<user_id>',
+     *   oauthApplicationId: '<oauth_application_id>'
+     * })
+     * ```
+     */
+    get(params: OptionalDefaults<GetOAuthApplicationParams>): Promise<OAuthApplicationProps>;
+    /**
+     * Creates a new OAuth application.
+     * @param userId the user ID
+     * @param rawData the oauth application payload
+     * @returns the created OAuth Application
+     * @throws if the request fails, or the user is not found
+     * @example
+     * ```javascript
+     * const oauthApplication = await client.oauthApplication.create({
+     *   userId: '<user_id>',
+     * }, {
+     *   name: 'Test-Name',
+     *   description: 'Test-Desc',
+     *   scopes: ['content_management_manage'],
+     *   redirectUri: 'https://redirect.uri.com',
+     *   confidential: true
+     * }
+     * ```
+     */
+    create(params: OptionalDefaults<GetUserParams>, rawData: CreateOAuthApplicationProps, headers?: RawAxiosRequestHeaders): Promise<OAuthApplicationProps>;
+    /**
+     * Updates details of a specific OAuth application.
+     * @param params the user and oauth application IDs
+     * @param rawData the oauth application payload
+     * @returns the updated oauth application
+     * @throws if the request fails, or the user or oauth application are not found
+     * @example
+     * ```javascript
+     *
+     * const oauthApplication = await client.oauthApplication.update({
+     *   userId: '<user_id>',
+     *   oauthApplicationId: '<oauth_application_id>'
+     * }, {
+     *   ...oauthApplication,
+     *   name: 'Update Test-Name',
+     *   description: 'Update Test-Desc',
+     * })
+     * ```
+     */
+    update(params: OptionalDefaults<GetOAuthApplicationParams>, rawData: UpdateOAuthApplicationProps, headers?: RawAxiosRequestHeaders): Promise<OAuthApplicationProps>;
+    /**
+     * Deletes a specific OAuth application.
+     * @param params the user and oauth application IDs
+     * @throws if the request fails, or the user or oauth application are not found
+     * @example
+     * ```javascript
+     * await client.oauthApplication.delete({
+     *   userId: '<user_id>',
+     *   oauthApplicationId: '<oauth_application_id>'
+     * })
+     * ```
+     */
+    delete(params: OptionalDefaults<GetOAuthApplicationParams>): Promise<void>;
+};

package/dist/types/plain/entities/organization.d.ts

@@ -0,0 +1,33 @@
+import type { PaginationQueryParams, CollectionProp, GetOrganizationParams } from '../../common-types';
+import type { OrganizationProps } from '../../entities/organization';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type OrganizationPlainClientAPI = {
+    /**
+     * Fetch all organizations the user has access to
+     * @param params Optional pagination query parameters
+     * @returns A collection of organizations
+     * @throws if the request fails, or no organizations are found
+     * @example
+     * ```javascript
+     * const organizations = await client.organization.getAll({
+     *   query: {
+     *     limit: 10,
+     *   }
+     * })
+     * ```
+     */
+    getAll(params?: OptionalDefaults<PaginationQueryParams>): Promise<CollectionProp<OrganizationProps>>;
+    /**
+     * Fetch a single organization by its ID
+     * @param params the organization ID
+     * @returns the requested organization
+     * @throws if the request fails, or the organization is not found
+     * @example
+     * ```javascript
+     * const organization = await client.organization.get({
+     *    organizationId: '<organization_id>'
+     * })
+     * ```
+     */
+    get(params: OptionalDefaults<GetOrganizationParams>): Promise<OrganizationProps>;
+};

package/dist/types/plain/entities/resource-provider.d.ts

@@ -0,0 +1,59 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { GetResourceProviderParams } from '../../common-types';
+import type { UpsertResourceProviderProps, ResourceProviderProps } from '../../entities/resource-provider';
+import type { OptionalDefaults } from '../wrappers/wrap';
+export type ResourceProviderPlainClientAPI = {
+    /**
+     * Fetches a Resource Provider
+     * @param params entity IDs to identify the Resource Provider
+     * @returns the Resource Provider
+     * @throws if the request fails or the Resource Provider is not found
+     * @example
+     * ```javascript
+     * const resourceProvider = await client.resourceProvider.get({
+     *   organizationId: '<organization_id>',
+     *   appDefinitionId: '<app_definition_id>',
+     * });
+     * ```
+     */
+    get(params: OptionalDefaults<GetResourceProviderParams>): Promise<ResourceProviderProps>;
+    /**
+     * Creates a Resource Provider
+     * @param params entity IDs to identify the Resource Provider
+     * @param rawData the Resource Provider data
+     * @returns the created Resource Provider
+     * @throws if the request fails, the App Definition is not found,
+     * a Resource Provider associated with the organization and app definition already exists,
+     * or the payload is malformed
+     * @example
+     * ```javascript
+     * // You need a valid AppDefinition with an activated AppBundle that has a configured Contentful function
+     * const resourceProvider = await client.resourceProvider.upsert(
+     *   {
+     *     organizationId: '<organization_id>',
+     *     appDefinitionId: '<app_definition_id>',
+     *   },
+     *   {
+     *      sys: { id: '<resource_provider_id>' },
+     *      type: 'function',
+     *      function: { sys: { id: '<contentful_function_id>', type: 'Link', linkType: 'Function' } },
+     *   }
+     * );
+     * ```
+     */
+    upsert(params: OptionalDefaults<GetResourceProviderParams>, rawData: UpsertResourceProviderProps, headers?: RawAxiosRequestHeaders): Promise<ResourceProviderProps>;
+    /**
+     * Deletes a ResourceProvider
+     * @param params entity IDs to identify the Resource Provider
+     * @throws if the request fails, the Resource Provider is not found
+     * or the Resource Provider is associated with an existing Resource Type
+     * @example
+     * ```javascript
+     * await client.resourceProvider.delete({
+     *   organizationId: '<organization_id>',
+     *   appDefinitionId: '<app_definition_id>',
+     * });
+     * ```
+     */
+    delete(params: OptionalDefaults<GetResourceProviderParams>): Promise<any>;
+};

package/dist/types/plain/entities/resource-type.d.ts

@@ -0,0 +1,14 @@
+import type { RawAxiosRequestHeaders } from 'axios';
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { BasicCursorPaginationOptions, CollectionProp, CursorPaginatedCollectionProp, GetResourceTypeParams, GetSpaceEnvironmentParams } from '../../common-types';
+import type { ResourceTypeProps, UpsertResourceTypeProps } from '../../export-types';
+import type { SpaceEnvResourceTypeProps } from '../../entities/resource-type';
+export type ResourceTypePlainClientAPI = {
+    get(params: OptionalDefaults<GetResourceTypeParams>): Promise<ResourceTypeProps>;
+    upsert(params: OptionalDefaults<GetResourceTypeParams>, rawData: UpsertResourceTypeProps, headers?: RawAxiosRequestHeaders): Promise<ResourceTypeProps>;
+    delete(params: OptionalDefaults<GetResourceTypeParams>): Promise<any>;
+    getForEnvironment(params: OptionalDefaults<GetSpaceEnvironmentParams> & {
+        query?: BasicCursorPaginationOptions;
+    }): Promise<CursorPaginatedCollectionProp<SpaceEnvResourceTypeProps>>;
+    getMany(params: OptionalDefaults<Omit<GetResourceTypeParams, 'resourceTypeId'>>): Promise<CollectionProp<ResourceTypeProps>>;
+};

package/dist/types/plain/entities/resource.d.ts

@@ -0,0 +1,40 @@
+import type { OptionalDefaults } from '../wrappers/wrap';
+import type { CursorPaginatedCollectionProp, GetResourceParams } from '../../common-types';
+import type { ResourceProps, ResourceQueryOptions } from '../../entities/resource';
+export type ResourcePlainAPI = {
+    /**
+     * Fetches all Resources.
+     * Supports fetching specific Resources by URNs or searching by a text query.
+     * @param params entity IDs to identify the Resources
+     * @params optional query params for search or lookup events
+     * @returns the Resources collection
+     * @throws if the request fails or the Resource Type is not found
+     * @example
+     * ```javascript
+     * // Lookup example
+     * const resources = await client.resource.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   resourceTypeId: '<resource_provider_id>:<resource_type_name>',
+     *   query: {
+     *     'sys.urn[in]': '<resource_urn1>,<resource_urn2>',
+     *     limit': <number>,
+     *   }
+     * });
+     *
+     * // Search example
+     * const resources = await client.resource.getMany({
+     *   spaceId: '<space_id>',
+     *   environmentId: '<environment_id>',
+     *   resourceTypeId: '<resource_provider_id>:<resource_type_name>',
+     *   query: {
+     *     'query': 'text',
+     *     'limit': <number>,
+     *   }
+     * });
+     * ```
+     */
+    getMany(params: OptionalDefaults<GetResourceParams> & {
+        query?: ResourceQueryOptions;
+    }): Promise<CursorPaginatedCollectionProp<ResourceProps>>;
+};