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

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

@@ -1,206 +0,0 @@
-import type { RawAxiosRequestHeaders } from 'axios';
-import type { CollectionProp, GetOrganizationParams, GetSpaceParams, QueryParams } from '../../common-types';
-import type { OptionalDefaults } from '../wrappers/wrap';
-import type { CreateRoleProps, RoleProps } from '../../entities/role';
-export type RolePlainClientAPI = {
-    /** Fetches a Role
-     *
-     * @param params Space ID and Role ID
-     * @returns the Role
-     * @throws if the request fails, or the Role is not found
-     * @example
-     * ```javascript
-     * const role = await client.role.get({
-     *   spaceId: '<space_id>',
-     *   roleId: '<role_id>',
-     * });
-     * ```
-     */
-    get(params: OptionalDefaults<GetSpaceParams & {
-        roleId: string;
-    }>): Promise<RoleProps>;
-    /** Fetches all Roles for the given Space
-     *
-     * @param params Space ID and optional query parameters
-     * @returns All the Roles for the given Space
-     * @throws if the request fails, or the Space is not found
-     * @example
-     * ```javascript
-     * const results = await client.role.getMany({
-     *   spaceId: '<space_id>',
-     *   query: {
-     *     limit: 100,
-     *   }
-     * });
-     * ```
-     */
-    getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<RoleProps>>;
-    /** Fetches all Roles for the given Organization
-     *
-     * @param params Organization ID and optional query parameters
-     * @returns All the Roles for the given Organization
-     * @throws if the request fails, or the Organization is not found
-     * @example
-     * ```javascript
-     * const results = await client.role.getManyForOrganization({
-     *   organizationId: '<organization_id>',
-     *   query: {
-     *     limit: 100,
-     *   }
-     * });
-     * ```
-     */
-    getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<RoleProps>>;
-    /** Creates a Role
-     *
-     * @param params Space ID and the Role to create
-     * @returns the created Role
-     * @throws if the request fails, the Space is not found, or the payload is malformed
-     * @example
-     * ```javascript
-     * const role = await client.role.create(
-     *   {
-     *      spaceId: '<space_id>',
-     *   },
-     *   {
-     *      name: 'My role',
-     *      description: 'My role description',
-     *      permissions: {
-     *        ContentModel: [
-     *         'read'
-     *        ],
-     *        ContentDelivery: 'all',
-     *        Environments: 'all',
-     *        EnvironmentAliases: 'all',
-     *        Settings: 'all'
-     *      },
-     *     policies: [
-     *       {
-     *         effect: 'allow',
-     *         actions: [
-     *           'read',
-     *           'create',
-     *           'update',
-     *           'delete',
-     *           'publish',
-     *           'unpublish',
-     *           'archive',
-     *           'unarchive'
-     *         ],
-     *         constraint: {
-     *           and: [
-     *           [
-     *            'equals',
-     *            {
-     *              doc: 'sys.type'
-     *            },
-     *            'Entry'
-     *           ]
-     *         ]
-     *       }
-     *     }
-     *   ]
-     * });
-     * ```
-     */
-    create(params: OptionalDefaults<GetSpaceParams>, data: CreateRoleProps, headers?: RawAxiosRequestHeaders): Promise<RoleProps>;
-    /** Creates a Role with a given ID
-     *
-     * @param params Space ID, Role ID, and the Role to create
-     * @returns the created Role
-     * @throws if the request fails, the Space is not found, or the payload is malformed
-     * @example
-     * ```javascript
-     * const role = await client.role.create(
-     *   {
-     *      spaceId: '<space_id>',
-     *      roleId: '<role_id>',
-     *   },
-     *   {
-     *      name: 'My role',
-     *      description: 'My role description',
-     *      permissions: {
-     *        ContentModel: [
-     *         'read'
-     *        ],
-     *        ContentDelivery: 'all',
-     *        Environments: 'all',
-     *        EnvironmentAliases: 'all',
-     *        Settings: 'all'
-     *      },
-     *     policies: [
-     *       {
-     *         effect: 'allow',
-     *         actions: [
-     *           'read',
-     *           'create',
-     *           'update',
-     *           'delete',
-     *           'publish',
-     *           'unpublish',
-     *           'archive',
-     *           'unarchive'
-     *         ],
-     *         constraint: {
-     *           and: [
-     *           [
-     *            'equals',
-     *            {
-     *              doc: 'sys.type'
-     *            },
-     *            'Entry'
-     *           ]
-     *         ]
-     *       }
-     *     }
-     *   ]
-     * });
-     * ```
-     */
-    createWithId(params: OptionalDefaults<GetSpaceParams & {
-        roleId: string;
-    }>, data: CreateRoleProps, headers?: RawAxiosRequestHeaders): Promise<RoleProps>;
-    /** Updates a Role
-     *
-     * @param params Space ID and Role ID
-     * @param rawData the Role update
-     * @returns the updated Role
-     * @throws if the request fails, the Role is not found, or the payload is malformed
-     * @example
-     * ```javascript
-     * let role = await client.role.get({
-     *   spaceId: '<space_id>',
-     *   roleId: '<role_id>',
-     * });
-     *
-     * role = await client.role.update(
-     *   {
-     *     spaceId: '<space_id>',
-     *     roleId: '<role_id>',
-     *   },
-     *   {
-     *     ...role,
-     *     name: 'My updated role name',
-     *   }
-     * );
-     * ```
-     */
-    update(params: OptionalDefaults<GetSpaceParams & {
-        roleId: string;
-    }>, rawData: RoleProps, headers?: RawAxiosRequestHeaders): Promise<RoleProps>;
-    /** Deletes a Role
-     *
-     * @param params Space ID and Role ID
-     * @throws if the request fails, or the Role is not found
-     * @example
-     * ```javascript
-     * await client.role.delete({
-     *   spaceId: '<space_id>',
-     *   roleId: '<role_id>',
-     * });
-     * ```
-     */
-    delete(params: OptionalDefaults<GetSpaceParams & {
-        roleId: string;
-    }>): Promise<any>;
-};

package/dist/types/plain/entities/space-member.d.ts

@@ -1,32 +0,0 @@
-import type { CollectionProp, GetSpaceParams, QueryParams } from '../../common-types';
-import type { SpaceMemberProps } from '../../entities/space-member';
-import type { OptionalDefaults } from '../wrappers/wrap';
-export type SpaceMemberPlainClientAPI = {
-    /**
-     * Fetch the space member
-     * @param params the space and member IDs
-     * @returns the space member
-     * @throws if the request fails, or the space member is not found
-     * @example ```javascript
-     * const spaceMember = await client.spaceMember.get({
-     *   spaceId: '<space_id>',
-     *   spaceMemberId: '<member_id>',
-     * });
-     * ```
-     */
-    get(params: OptionalDefaults<GetSpaceParams & {
-        spaceMemberId: string;
-    }>): Promise<SpaceMemberProps>;
-    /**
-     * Fetches all the space members for a given space
-     * @param params a space ID and query parameters
-     * @returns a collection of space members
-     * @throws if the request fails, the space is not found, or the query parameters are malformed
-     * @example ```javascript
-     * const spaceMember = await client.spaceMember.getMany({
-     *   spaceId: '<space_id>',
-     * });
-     * ```
-     */
-    getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<SpaceMemberProps>>;
-};

package/dist/types/plain/entities/space-membership.d.ts

@@ -1,155 +0,0 @@
-import type { RawAxiosRequestHeaders } from 'axios';
-import type { GetSpaceMembershipProps, GetSpaceParams, QueryParams, CollectionProp, GetOrganizationParams } from '../../common-types';
-import type { OptionalDefaults } from '../wrappers/wrap';
-import type { CreateSpaceMembershipProps, SpaceMembershipProps } from '../../entities/space-membership';
-export type SpaceMembershipPlainClientAPI = {
-    /**
-     * Fetches a space membership for a given space
-     * @param params the space and membership IDs
-     * @returns the space membership
-     * @throws if the request fails, or the space membership is not found
-     * @example ```javascript
-     * const spaceMembership = await client.spaceMembership.get({
-     *   spaceId: '<space_id>',
-     *   spaceMembershipId: '<membership_id>',
-     * });
-     * ```
-     */
-    get(params: OptionalDefaults<GetSpaceMembershipProps>): Promise<SpaceMembershipProps>;
-    /**
-     * Fetches all of the memberships for a given space
-     * @param params a space ID
-     * @returns a collection of space memberships
-     * @throws if the request fails, the space is not found, or the query parameters are malformed
-     * @example ```javascript
-     * const spaceMemberships = await client.spaceMembership.getMany({
-     *   spaceId: '<space_id>',
-     *   spaceMembershipId: '<membership_id>',
-     * });
-     * ```
-     */
-    getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<SpaceMembershipProps>>;
-    /**
-     * Fetches the space membership within a given organization
-     * @param params the organization and membership IDs
-     * @returns the space membership
-     * @throws if the request fails, or the organization or the space membership is not found
-     * @example ```javascript
-     * const spaceMembership = await client.spaceMembership.getForOrganization({
-     *   spaceId: '<space_id>',
-     *   spaceMembershipId: '<membership_id>',
-     * });
-     * ```
-     */
-    getForOrganization(params: OptionalDefaults<GetOrganizationParams & {
-        spaceMembershipId: string;
-    }>): Promise<SpaceMembershipProps>;
-    /**
-     * Fetches all of the space memberships within a given organization
-     * @param params the organization and query parameterss
-     * @returns a collection of space memberships
-     * @throws if the request fails, the organization is not found, or the query parameters are malformed
-     * @example ```javascript
-     * const spaceMemberships = await client.spaceMembership.getManyForOrganization({
-     *   organizationId: '<organization_id>',
-     *   spaceMembershipId: '<membership_id>',
-     * });
-     * ```
-     */
-    getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<SpaceMembershipProps>>;
-    /**
-     * Creates a space membership
-     * @param params the space ID
-     * @param data the space membership data
-     * @returns the created space membership
-     * @throws if the request fails, the space cannot be found, or the data is malformed
-     * @example ```javascript
-     * const spaceMembership = await client.spaceMembership.create(
-     *   {
-     *     spaceId: '<space_id>',
-     *   },
-     *   {
-     *     admin: false,
-     *     roles: [
-     *       {
-     *         sys: {
-     *           type: 'Link',
-     *           linkType: 'Role',
-     *           id: '<role_id>',
-     *         },
-     *       },
-     *     ],
-     *     email: 'foo@example.com',
-     *   }
-     * );
-     * ```
-     */
-    create(params: OptionalDefaults<GetSpaceParams>, data: CreateSpaceMembershipProps, headers?: RawAxiosRequestHeaders): Promise<SpaceMembershipProps>;
-    /**
-     * Creates a space membership with a specific ID
-     * @param params the space ID and chosen membership ID
-     * @param data the space membership data
-     * @returns the created space membership
-     * @throws if the request fails, the space cannot be found, or the data is malformed
-     * @example ```javascript
-     * const spaceMembership = await client.spaceMembership.createWithId(
-     *   {
-     *     spaceId: '<space_id>',
-     *     spaceMembershipId: '<membership_id>',
-     *   },
-     *   {
-     *     admin: false,
-     *     roles: [
-     *       {
-     *         sys: {
-     *           type: 'Link',
-     *           linkType: 'Role',
-     *           id: '<role_id>',
-     *         },
-     *       },
-     *     ],
-     *     email: 'foo@example.com',
-     *   }
-     * );
-     * ```
-     */
-    createWithId(params: OptionalDefaults<GetSpaceMembershipProps>, data: CreateSpaceMembershipProps, headers?: RawAxiosRequestHeaders): Promise<SpaceMembershipProps>;
-    /**
-     * Updates a space membership
-     * @param params the space and membership IDs
-     * @param rawData the space membership update
-     * @returns the updated space membership
-     * @throws if the request fails, the space membership is not found, or the payload is malformed
-     * @example ```javascript
-     * let spaceMembership = await client.spaceMembership.get({
-     *   spaceId: '<space_id>',
-     *   spaceMembershipId: '<membership_id>',
-     * });
-     *
-     * spaceMembership = await client.spaceMembership.update(
-     *   {
-     *     spaceId: '<space_id>',
-     *     spaceMembershipId: '<membership_id>',
-     *   },
-     *   {
-     *     ...spaceMembership,
-     *     admin: true,
-     *   }
-     * );
-     * ```
-     */
-    update(params: OptionalDefaults<GetSpaceMembershipProps>, rawData: SpaceMembershipProps, headers?: RawAxiosRequestHeaders): Promise<SpaceMembershipProps>;
-    /**
-     * Deletes a space membership
-     * @param params the space and membership IDs
-     * @returns void
-     * @throws if the request fails, or the space membership is not found
-     * @example ```javascript
-     * await client.spaceMembership.delete({
-     *   spaceId: '<space_id>',
-     *   spaceMembershipId: '<membership_id>',
-     * });
-     * ```
-     */
-    delete(params: OptionalDefaults<GetSpaceMembershipProps>): Promise<any>;
-};

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

@@ -1,102 +0,0 @@
-import type { RawAxiosRequestHeaders } from 'axios';
-import type { GetSpaceParams, QueryParams, CollectionProp, GetOrganizationParams } from '../../common-types';
-import type { OptionalDefaults } from '../wrappers/wrap';
-import type { SpaceProps } from '../../entities/space';
-export type SpacePlainClientAPI = {
-    /**
-     * Fetches a space
-     * @param params the space ID
-     * @returns the space
-     * @throws if the request fails, or the space is not found
-     * @example ```javascript
-     * const space = await client.space.get({
-     *   spaceId: '<space_id>',
-     * });
-     * ```
-     */
-    get(params: OptionalDefaults<GetSpaceParams>): Promise<SpaceProps>;
-    /**
-     * Fetches all the spaces that the logged in user has access to
-     * @param params (optional) filter and pagination query parameters
-     * @returns a collection of spaces
-     * @throws if the request fails, or the query parameters are malformed
-     * @example ```javascript
-     * const space = await client.space.getMany({
-     *   query: {
-     *     limit: 10,
-     *   },
-     * });
-     * ```
-     */
-    getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<SpaceProps>>;
-    /**
-     * Fetches all the spaces in the given organization
-     * @param params the organization ID and query parameters
-     * @returns a collection of spaces
-     * @throws if the request fails, the organization is not found, or the query parameters are malformed
-     * @example ```javascript
-     * const space = await client.space.getManyForOrganization({
-     *   organizationId: '<organization_id>',
-     *   query: {
-     *     limit: 10,
-     *   },
-     * });
-     * ```
-     */
-    getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<SpaceProps>>;
-    /**
-     * Creates a space
-     * @param params an organization ID
-     * @param payload the space to create
-     * @returns the created space
-     * @throws if the request fails, or the payload is malformed
-     * @example ```javascript
-     * const space = await client.space.create(
-     *   {
-     *     organizationId: '<organization_id>',
-     *   },
-     *   {
-     *     name: 'New space',
-     *   }
-     * );
-     * ```
-     */
-    create(params: OptionalDefaults<{
-        organizationId?: string;
-    }>, payload: Omit<SpaceProps, 'sys'>, headers?: RawAxiosRequestHeaders): Promise<any>;
-    /**
-     * Updates a space
-     * @param params the space ID
-     * @param payload the space update
-     * @returns the updated space
-     * @throws if the request fails, the space is not found, or the payload is malformed
-     * @example ```javascript
-     * let space = await client.space.get({
-     *   spaceId: '<space_id>',
-     * });
-     *
-     * space = await client.space.update(
-     *   {
-     *     spaceId: '<space_id>',
-     *   },
-     *   {
-     *     ...space.sys,
-     *     name: 'New name'
-     *   }
-     * );
-     * ```
-     */
-    update(params: OptionalDefaults<GetSpaceParams>, payload: SpaceProps, headers?: RawAxiosRequestHeaders): Promise<SpaceProps>;
-    /**
-     * Deletes a space
-     * @param params the space ID
-     * @returns void
-     * @throws if the request fails, or the space is not found
-     * @example ```javascript
-     * await client.space.delete({
-     *   spaceId: '<space_id>',
-     * });
-     * ```
-     */
-    delete(params: OptionalDefaults<GetSpaceParams>): Promise<any>;
-};

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

@@ -1,103 +0,0 @@
-import type { RawAxiosRequestHeaders } from 'axios';
-import type { GetTagParams, GetSpaceEnvironmentParams, QueryParams, CollectionProp } from '../../common-types';
-import type { UpdateTagProps, DeleteTagParams } from '../../entities/tag';
-import type { TagProps, CreateTagProps } from '../../export-types';
-import type { OptionalDefaults } from '../wrappers/wrap';
-export type TagPlainClientAPI = {
-    /**
-     * Fetch a single tag by ID
-     * @param params the tag ID and the IDs of the space and environment
-     * @returns the tag
-     * @throws if the space, environment, or tag are not found
-     * @example
-     * ```javascript
-     * const tag = await client.tag.get({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   tagId: '<tag_id>',
-     * });
-     * ```
-     */
-    get(params: OptionalDefaults<GetTagParams>): Promise<TagProps>;
-    /**
-     * Fetch all tags in a space and environment
-     * @param params the space and environment IDs, along with optional query parameters to filter results
-     * @returns a collection of tags
-     * @throws if the space or environment are not found
-     * @example
-     * ```javascript
-     * const tags = await client.tag.getMany({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   query: {
-     *     limit: 10,
-     *   },
-     * });
-     * ```
-     */
-    getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<TagProps>>;
-    /**
-     * Create a new tag
-     * @param params the space and environment ID to create the tag in
-     * @param data the tag data
-     * @returns the created tag
-     * @throws if the space or environment are not found or the payload is malformed
-     * @example
-     * ```javascript
-     * const tag = await client.tag.createWithId({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   tagId: '<tag_id>'
-     * }, {
-     *   name: '<tag_name>',
-     *   sys: {
-     *     visibility: "public",
-     *   }
-     * });
-     * ```
-     */
-    createWithId(params: OptionalDefaults<GetTagParams>, rawData: CreateTagProps): Promise<TagProps>;
-    /**
-     * Update a tag
-     * @param params the space, environment, and tag IDs
-     * @param rawData the updated tag data
-     * @returns the updated tag
-     * @throws if the space, environment, or tag are not found, or the payload is malformed
-     * @example
-     * ```javascript
-     * let tag = await client.tag.get({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   tagId: '<tag_id>',
-     * });
-     *
-     * tag = await client.tag.update(
-     *   {
-     *     spaceId: '<space_id>',
-     *     environmentId: '<environment_id>',
-     *     tagId: '<tag_id>',
-     *   },
-     *   {
-     *     ...tag,
-     *     name: 'New Name',
-     *   }
-     * );
-     * ```
-     */
-    update(params: OptionalDefaults<GetTagParams>, rawData: UpdateTagProps, headers?: RawAxiosRequestHeaders): Promise<TagProps>;
-    /**
-     * Delete a single tag by ID and version
-     * @param params the tag ID, version, and the IDs of the space and environment
-     * @throws if the space, environment, tag, or tag version are not found
-     * @example
-     * ```javascript
-     * await client.tag.delete({
-     *   spaceId: '<space_id>',
-     *   environmentId: '<environment_id>',
-     *   tagId: '<tag_id>',
-     *   version: <tag_version>,
-     * });
-     * ```
-     */
-    delete(params: OptionalDefaults<DeleteTagParams>): Promise<any>;
-};