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

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

@@ -0,0 +1,206 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,103 @@
+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>;
+};