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

package/dist/typings/entities/content-type.d.ts

@@ -0,0 +1,217 @@
+import type { Except, RequireAtLeastOne, SetOptional } from 'type-fest';
+import type { BasicMetaSysProps, Collection, CursorPaginatedCollectionProp, DefaultElements, Link, MakeRequest, SysLink } from '../common-types';
+import type { ContentFields } from './content-type-fields';
+import type { EditorInterface } from './editor-interface';
+import type { Snapshot, SnapshotProps } from './snapshot';
+type TaxonomyConceptValidationLink = Link<'TaxonomyConcept'> & {
+    required?: boolean;
+};
+type TaxonomyConceptSchemeValidationLink = Link<'TaxonomyConceptScheme'> & {
+    required?: boolean;
+};
+export type ContentTypeMetadata = {
+    annotations?: RequireAtLeastOne<{
+        ContentType?: AnnotationAssignment[];
+        ContentTypeField?: Record<string, AnnotationAssignment[]>;
+    }, 'ContentType' | 'ContentTypeField'>;
+    taxonomy?: Array<TaxonomyConceptValidationLink | TaxonomyConceptSchemeValidationLink>;
+};
+export type AnnotationAssignment = Link<'Annotation'> & {
+    parameters?: Record<string, string | number | boolean>;
+};
+export type ContentTypeProps = {
+    sys: BasicMetaSysProps & {
+        space: SysLink;
+        environment: SysLink;
+        firstPublishedAt?: string;
+        publishedCounter?: number;
+        publishedVersion?: number;
+    };
+    name: string;
+    description: string;
+    /** Field used as the main display field for Entries */
+    displayField: string;
+    /** All the fields contained in this Content Type */
+    fields: ContentFields[];
+    metadata?: ContentTypeMetadata;
+};
+export type CreateContentTypeProps = SetOptional<Except<ContentTypeProps, 'sys'>, 'description' | 'displayField'>;
+type ContentTypeApi = {
+    /**
+     * Sends an update to the server with any changes made to the object's properties. <br />
+     * <strong>Important note about deleting fields</strong>: The standard way to delete a field is with two updates: first omit the property from your responses (set the field attribute "omitted" to true), and then
+     * delete it by setting the attribute "deleted" to true. See the "Deleting fields" section in the
+     * <a href="https://www.contentful.com/developers/docs/references/content-management-api/#/reference/content-types/content-type">API reference</a> for more reasoning. Alternatively,
+     * you may use the convenience method omitAndDeleteField to do both steps at once.
+     * @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.getContentType('<contentType_id>'))
+     * .then((contentType) => {
+     *  contentType.name = 'New name'
+     *  return contentType.update()
+     * })
+     * .then(contentType => console.log(contentType))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<ContentType>;
+    /**
+     * 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.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.delete())
+     * .then(() => console.log('contentType deleted'))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+    /**
+     * Publishes the object
+     * @return Object returned from the server with updated metadata.
+     * @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.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.publish())
+     * .then((contentType) => console.log(`${contentType.sys.id} is published`))
+     * .catch(console.error)
+     * ```
+     */
+    publish(): Promise<ContentType>;
+    /**
+     * Unpublishes the object
+     * @return Object returned from the server with updated metadata.
+     * @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.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.unpublish())
+     * .then((contentType) => console.log(`${contentType.sys.id} is unpublished`))
+     * .catch(console.error)
+     * ```
+     */
+    unpublish(): Promise<ContentType>;
+    /**
+     * Gets the editor interface for the object <br />
+     * <strong>Important note</strong>: The editor interface only represent a published contentType.<br />
+     * To get the most recent representation of the contentType make sure to publish it first
+     * @return Object returned from the server with the current editor interface.
+     * @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.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.getEditorInterface())
+     * .then((editorInterface) => console.log(editorInterface.contorls))
+     * .catch(console.error)
+     * ```
+     */
+    getEditorInterface(): Promise<EditorInterface>;
+    /**
+     * Checks if the contentType is in draft mode. This means it is not published.
+     */
+    isDraft(): boolean;
+    /**
+     * Checks if the contentType is published. A published contentType might have unpublished changes (@see {ContentType.isUpdated})
+     */
+    isPublished(): boolean;
+    /**
+     * Checks if the contentType is updated. This means the contentType was previously published but has unpublished changes.
+     */
+    isUpdated(): boolean;
+    /**
+     * Omits and deletes a field if it exists on the contentType. This is a convenience method which does both operations at once and potentially less
+     * safe than the standard way. See note about deleting fields on the Update method.
+     * @return Object returned from the server with updated metadata.
+     */
+    omitAndDeleteField(id: string): Promise<ContentType>;
+    /**
+     * Gets a snapshot of a contentType
+     * @param snapshotId - Id of the snapshot
+     * @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.getContentType('<contentType_id>'))
+     * .then((entry) => entry.getSnapshot('<snapshot-id>'))
+     * .then((snapshot) => console.log(snapshot))
+     * .catch(console.error)
+     * ```
+     */
+    getSnapshot(snapshotId: string): Promise<SnapshotProps<ContentTypeProps>>;
+    /**
+     * Gets all snapshots of a contentType
+     * @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.getContentType('<contentType_id>'))
+     * .then((entry) => entry.getSnapshots())
+     * .then((snapshots) => console.log(snapshots.items))
+     * .catch(console.error)
+     * ```
+     */
+    getSnapshots(): Promise<Collection<Snapshot<ContentTypeProps>, SnapshotProps<ContentTypeProps>>>;
+};
+export interface ContentType extends ContentTypeProps, DefaultElements<ContentTypeProps>, ContentTypeApi {
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw content type data
+ * @return Wrapped content type data
+ */
+export declare function wrapContentType(makeRequest: MakeRequest, data: ContentTypeProps): ContentType;
+/**
+ * @private
+ */
+export declare const wrapContentTypeCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<ContentTypeProps>) => Collection<ContentType, ContentTypeProps>;
+/**
+ * @private
+ */
+export declare const wrapContentTypeCursorPaginatedCollection: (makeRequest: MakeRequest, data: CursorPaginatedCollectionProp<ContentTypeProps>) => import("../common-types").CursorPaginatedCollection<ContentType, ContentTypeProps>;
+export {};

package/dist/typings/entities/editor-interface.d.ts

@@ -0,0 +1,168 @@
+import type { MetaSysProps, MetaLinkProps, DefaultElements, MakeRequest } from '../common-types';
+import type { DefinedParameters } from './widget-parameters';
+interface WidgetConfig {
+    /**
+     * Type of the widget used
+     */
+    widgetNamespace?: string;
+    /**
+     * ID of the widget used
+     */
+    widgetId?: string;
+    /**
+     * Instance parameter values
+     */
+    settings?: DefinedParameters;
+}
+export interface Control extends WidgetConfig {
+    /**
+     * ID of the customized field
+     */
+    fieldId: string;
+}
+export interface GroupControl extends WidgetConfig {
+    /**
+     * ID of the customized field group
+     */
+    groupId: string;
+}
+export interface FieldGroupItem {
+    groupId: string;
+    name: string;
+    items: EditorLayoutItem[];
+}
+export interface FieldItem {
+    fieldId: string;
+}
+export type EditorLayoutItem = FieldItem | FieldGroupItem;
+export interface Editor {
+    /**
+     * Type of the widget used
+     */
+    widgetNamespace: string;
+    /**
+     * ID of the widget used
+     */
+    widgetId: string;
+    /**
+     * Widget will be enabled if disabled property is missing
+     */
+    disabled?: boolean;
+    /**
+     * Instance parameter values
+     */
+    settings?: DefinedParameters;
+}
+export interface SidebarItem {
+    /**
+     * Type of the widget used
+     */
+    widgetNamespace: string;
+    /**
+     * ID of the widget used
+     */
+    widgetId: string;
+    /**
+     * Widget will be enabled if disabled property is missing
+     */
+    disabled?: boolean;
+    /**
+     * Instance parameter values
+     */
+    settings?: DefinedParameters;
+}
+export type EditorInterfaceProps = {
+    sys: MetaSysProps & {
+        space: {
+            sys: MetaLinkProps;
+        };
+        environment: {
+            sys: MetaLinkProps;
+        };
+        contentType: {
+            sys: MetaLinkProps;
+        };
+    };
+    /**
+     * Array of fields and their associated widgetId
+     */
+    controls?: Control[];
+    /**
+     * Array of field groups and their associated widgetId
+     */
+    groupControls?: GroupControl[];
+    /**
+     * Array of editors. Defaults will be used if property is missing.
+     */
+    editors?: Editor[];
+    /**
+     * Legacy singular editor override
+     */
+    editor?: Editor;
+    /**
+     * Array of editor layout field groups
+     */
+    editorLayout?: FieldGroupItem[];
+    /**
+     * Array of sidebar widgets. Defaults will be used if property is missing.
+     */
+    sidebar?: SidebarItem[];
+};
+export interface EditorInterface extends EditorInterfaceProps, DefaultElements<EditorInterfaceProps> {
+    /**
+     * Gets a control for a specific field
+     * @return control object for specific field
+     * ```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.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.getEditorInterface())
+     * .then((editorInterface) => {
+     *  control = editorInterface.getControlForField('<field-id>')
+     *  console.log(control)
+     * })
+     * .catch(console.error)
+     * ```
+     */
+    getControlForField(id: string): null | Control;
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @return Object returned from the server with updated changes.
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment_id>'))
+     * .then((environment) => environment.getContentType('<contentType_id>'))
+     * .then((contentType) => contentType.getEditorInterface())
+     * .then((editorInterface) => {
+     *  editorInterface.controls[0] = { "fieldId": "title", "widgetId": "singleLine"}
+     *  editorInterface.editors = [
+     *    { "widgetId": "custom-widget", "widgetNamespace": "app" }
+     *  ]
+     *  return editorInterface.update()
+     * })
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<EditorInterface>;
+}
+/**
+ * @private
+ */
+export declare function wrapEditorInterface(makeRequest: MakeRequest, data: EditorInterfaceProps): EditorInterface;
+/**
+ * @private
+ */
+export declare const wrapEditorInterfaceCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<EditorInterfaceProps>) => import("../common-types").Collection<EditorInterface, EditorInterfaceProps>;
+export {};

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

@@ -0,0 +1,57 @@
+import type { CollectionProp, CursorPaginatedCollectionProp, DefaultElements, EntryMetaSysProps, KeyValueMap, MakeRequest, MetadataProps } from '../common-types';
+import type { ContentfulEntryApi } from '../create-entry-api';
+import type { AssetProps } from './asset';
+export type EntryProps<T = KeyValueMap, S = unknown> = {
+    sys: EntryMetaSysProps & S;
+    metadata?: MetadataProps;
+    fields: T;
+};
+export type CreateEntryProps<TFields = KeyValueMap> = Omit<EntryProps<TFields>, 'sys'>;
+export type EntryReferenceError = {
+    sys: {
+        type: 'error';
+        id: 'notResolvable';
+    };
+    details: {
+        type: 'Link';
+        linkType: 'Entry' | 'Asset';
+        id: string;
+    };
+};
+export interface EntryReferenceProps extends CollectionProp<EntryProps> {
+    includes?: {
+        Entry?: EntryProps[];
+        Asset?: AssetProps[];
+    };
+    errors?: EntryReferenceError[];
+}
+export type EntryReferenceOptionsProps = {
+    include?: number;
+};
+export interface Entry extends EntryProps, DefaultElements<EntryProps>, ContentfulEntryApi {
+}
+export type WithResourceName<T extends {
+    sys: unknown;
+}> = T extends {
+    sys: infer Sys;
+} ? Omit<T, 'sys'> & {
+    sys: Sys & {
+        urn: string;
+    };
+} : never;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw entry data
+ * @return Wrapped entry data
+ */
+export declare function wrapEntry(makeRequest: MakeRequest, data: EntryProps): Entry;
+/**
+ * Data is also mixed in with link getters if links exist and includes were requested
+ * @private
+ */
+export declare const wrapEntryCollection: (makeRequest: MakeRequest, data: CollectionProp<EntryProps<KeyValueMap, unknown>>) => import("../common-types").Collection<Entry, EntryProps<KeyValueMap, unknown>>;
+/**
+ * @private
+ */
+export declare const wrapEntryTypeCursorPaginatedCollection: (makeRequest: MakeRequest, data: CursorPaginatedCollectionProp<EntryProps<KeyValueMap, unknown>>) => import("../common-types").CursorPaginatedCollection<Entry, EntryProps<KeyValueMap, unknown>>;

package/dist/typings/entities/environment-alias.d.ts

@@ -0,0 +1,74 @@
+import type { DefaultElements, MetaLinkProps, BasicMetaSysProps, SysLink, MakeRequest } from '../common-types';
+export type EnvironmentAliasProps = {
+    /**
+     * System meta data
+     */
+    sys: BasicMetaSysProps & {
+        space: SysLink;
+    };
+    environment: {
+        sys: MetaLinkProps;
+    };
+};
+export type CreateEnvironmentAliasProps = Omit<EnvironmentAliasProps, 'sys'>;
+export interface EnvironmentAlias extends EnvironmentAliasProps, DefaultElements<EnvironmentAliasProps> {
+    /**
+     * Sends an update to the server with any changes made to the object's properties. Currently, you can only change the id of the alias's underlying environment. See the example below.
+     * @memberof EnvironmentAlias
+     * @func update
+     * @return {Promise<EnvironmentAlias>} Object returned from the server with updated changes.
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironmentAlias('<environment_alias_id>'))
+     * .then((alias) => {
+     *   alias.environment.sys.id = '<environment_id>'
+     *   return alias.update()
+     * })
+     * .then((alias) => console.log(`alias ${alias.sys.id} updated.`))
+     * .catch(console.error)
+     * ```
+     */
+    update(): Promise<EnvironmentAlias>;
+    /**
+     * Deletes this object on the server.
+     * @memberof EnvironmentAlias
+     * @func delete
+     * @return {Promise<void>} Promise for the deletion. It contains no data, but the Promise error case should be handled.
+     * ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironmentAlias('<environment_alias_id>'))
+     * .then((alias) => {
+     *   return alias.delete()
+     * })
+     * .then(() => console.log(`Alias deleted.`))
+     * .catch(console.error)
+     * ```
+     */
+    delete(): Promise<void>;
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias data
+ * @return Wrapped environment alias data
+ */
+export declare function wrapEnvironmentAlias(makeRequest: MakeRequest, data: EnvironmentAliasProps): EnvironmentAlias;
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias collection data
+ * @return Wrapped environment alias collection data
+ */
+export declare const wrapEnvironmentAliasCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<EnvironmentAliasProps>) => import("../common-types").Collection<EnvironmentAlias, EnvironmentAliasProps>;

package/dist/typings/entities/environment-template-installation.d.ts

@@ -0,0 +1,57 @@
+import type { BasicMetaSysProps, DefaultElements, ISO8601Timestamp, Link, MakeRequest, VersionedLink } from '../common-types';
+type JsonObject = {
+    [Key in string]?: JsonValue;
+};
+type JsonArray = Array<JsonValue>;
+type JsonValue = string | number | boolean | JsonObject | JsonArray | null;
+declare enum EnvironmentTemplateInstallationStatuses {
+    created = "created",
+    inProgress = "inProgress",
+    failed = "failed",
+    succeeded = "succeeded",
+    disconnected = "disconnected",
+    inRetry = "inRetry"
+}
+export type EnvironmentTemplateInstallationStatus = keyof typeof EnvironmentTemplateInstallationStatuses;
+export type EnvironmentTemplateInstallationProps = {
+    sys: BasicMetaSysProps & {
+        type: 'EnvironmentTemplateInstallation';
+        space: Link<'Space'>;
+        template: VersionedLink<'Template'>;
+        status: EnvironmentTemplateInstallationStatus;
+        createdAt: ISO8601Timestamp;
+        updatedAt: ISO8601Timestamp;
+        createdBy: Link<'User' | 'AppDefinition'>;
+        updatedBy: Link<'User' | 'AppDefinition'>;
+        completedAt?: ISO8601Timestamp;
+        errors?: JsonArray;
+        environment: Link<'Environment'>;
+        version: number;
+    };
+};
+export type CreateEnvironmentTemplateInstallationProps = {
+    version: number;
+    takeover?: {
+        items: Link<'ContentType'>[];
+    };
+    changeSet?: Link<'ChangeSet'>;
+    deleteDeletedFields?: boolean;
+};
+export type ValidateEnvironmentTemplateInstallationProps = Omit<CreateEnvironmentTemplateInstallationProps, 'version'>;
+export type ValidationFinding = {
+    message: string;
+    details: Record<string, unknown>;
+};
+export type EnvironmentTemplateValidationProps<T = ValidationFinding> = {
+    sys: {
+        type: 'Array';
+        environment: Link<'Environment'>;
+        space: Link<'Space'>;
+        changeSet: Link<'ChangeSet'>;
+    };
+    items: T[];
+};
+export type EnvironmentTemplateInstallation = EnvironmentTemplateInstallationProps & DefaultElements<EnvironmentTemplateInstallationProps>;
+export declare function wrapEnvironmentTemplateInstallation(makeRequest: MakeRequest, data: EnvironmentTemplateInstallationProps): EnvironmentTemplateInstallation;
+export declare const wrapEnvironmentTemplateInstallationCollection: (makeRequest: MakeRequest, data: import("../common-types").CursorPaginatedCollectionProp<EnvironmentTemplateInstallationProps>) => import("../common-types").CursorPaginatedCollection<EnvironmentTemplateInstallation, EnvironmentTemplateInstallationProps>;
+export {};

package/dist/typings/entities/environment-template.d.ts

@@ -0,0 +1,40 @@
+import type { BasicMetaSysProps, Link, MakeRequest, DefaultElements } from '../common-types';
+import type { ContentfulEnvironmentTemplateApi } from '../create-environment-template-api';
+import type { ContentTypeProps } from './content-type';
+import type { EditorInterfaceProps } from './editor-interface';
+export type Hint = {
+    operation: 'renameFieldId';
+    fieldId: string;
+    previousFieldId: string;
+};
+export interface EditorInterfaceTemplateProps extends Omit<EditorInterfaceProps, 'sys'> {
+    contentTypeTemplate: Link<'ContentTypeTemplate'>;
+}
+export interface ContentTypeTemplateProps extends Omit<ContentTypeProps, 'sys'> {
+    id: string;
+    basedOn?: {
+        space: Link<'Space'>;
+        environment: Link<'Environment'>;
+        contentType: Link<'ContentType'>;
+    };
+    hints?: Array<Hint>;
+}
+export type EnvironmentTemplateProps = {
+    sys: BasicMetaSysProps & {
+        version: number;
+        organization: Link<'Organization'>;
+    };
+    name: string;
+    description?: string;
+    versionName: string;
+    versionDescription?: string;
+    entities: {
+        contentTypeTemplates: Array<ContentTypeTemplateProps>;
+        editorInterfaceTemplates: Array<EditorInterfaceTemplateProps>;
+    };
+    forTemplatedSpaces?: boolean;
+};
+export type CreateEnvironmentTemplateProps = Omit<EnvironmentTemplateProps, 'sys'>;
+export type EnvironmentTemplate = EnvironmentTemplateProps & DefaultElements<EnvironmentTemplateProps> & ContentfulEnvironmentTemplateApi;
+export declare function wrapEnvironmentTemplate(makeRequest: MakeRequest, data: EnvironmentTemplateProps, organizationId: string): EnvironmentTemplate;
+export declare const wrapEnvironmentTemplateCollection: (makeRequest: MakeRequest, data: import("../common-types").CursorPaginatedCollectionProp<EnvironmentTemplateProps>, organizationId: string) => import("../common-types").CursorPaginatedCollection<EnvironmentTemplate, EnvironmentTemplateProps>;

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

@@ -0,0 +1,38 @@
+import type { ContentfulEnvironmentAPI } from '../create-environment-api';
+import type { DefaultElements, SysLink, BasicMetaSysProps, MakeRequest } from '../common-types';
+type EnvironmentMetaSys = BasicMetaSysProps & {
+    status: SysLink;
+    space: SysLink;
+    aliases?: Array<SysLink>;
+    aliasedEnvironment?: SysLink;
+};
+export type EnvironmentProps = {
+    /**
+     * System metadata
+     */
+    sys: EnvironmentMetaSys;
+    /**
+     * Name of the environment
+     */
+    name: string;
+};
+export type CreateEnvironmentProps = Partial<Omit<EnvironmentProps, 'sys'>>;
+export type Environment = ContentfulEnvironmentAPI & EnvironmentProps & DefaultElements<EnvironmentProps>;
+/**
+ * This method creates the API for the given environment with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with a environment id, so the base path for requests now has the
+ * environment id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for a Environment
+ * @return
+ */
+export declare function wrapEnvironment(makeRequest: MakeRequest, data: EnvironmentProps): Environment;
+/**
+ * This method wraps each environment in a collection with the environment API. See wrapEnvironment
+ * above for more details.
+ * @private
+ */
+export declare const wrapEnvironmentCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<EnvironmentProps>) => import("../common-types").Collection<Environment, EnvironmentProps>;
+export {};