fetch-confluence

A simple and typed library, based on OpenAPI spec from developer.atlassian.com, for accessing product APIs.

Fetch Confluence - Documentation

Contents

• AuditApi
• ContentApi
• ContentBlueprintApi
• ContentIdChildApi
• ContentIdChildAttachmentApi
• ContentIdDescendantApi
• ContentIdLabelApi
• ContentIdNotificationApi
• ContentIdPropertyApi
• ContentIdRestrictionApi
• ContentIdVersionApi
• ContentbodyConvertToApi
• DefaultApi
• GroupApi
• LongtaskApi
• RelationApi
• SearchApi
• SearchUserApi
• SettingsApi
• SettingsLookandfeelApi
• SettingsThemeApi
• SpaceApi
• SpaceSpaceKeyPropertyApi
• SpaceSpaceKeyThemeApi
• SpaceSpaceKeyWatchApi
• TemplateApi
• UserApi
• UserEmailApi
• UserEmailBulkApi

Methods

---

The AuditApi object

createAuditRecord() - Create audit record

Creates a record in the audit log.

Usage:

import { AuditApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new AuditApi(config).createAuditRecord({
  AuditRecordCreate: { ... }
});

exportAuditRecords() - Export audit records

Exports audit records as a CSV file or ZIP file.

Usage:

import { AuditApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new AuditApi(config).exportAuditRecords({ ...args });

getAuditRecords() - Get audit records

Returns all records in the audit log, optionally for a certain date range. This contains information about events like space exports, group membership changes, app installations, etc. For more information, see Audit log in the Confluence administrator's guide.

Usage:

import { AuditApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new AuditApi(config).getAuditRecords({ ...args });

getAuditRecordsForTimePeriod() - Get audit records for time period

Returns records from the audit log, for a time period back from the current date. For example, you can use this method to get the last 3 months of records.

Usage:

import { AuditApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new AuditApi(config).getAuditRecordsForTimePeriod({ ...args });

getRetentionPeriod() - Get retention period

Returns the retention period for records in the audit log. The retention period is how long an audit record is kept for, from creation date until it is deleted.

Usage:

import { AuditApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new AuditApi(config).getRetentionPeriod({ ...args });

setRetentionPeriod() - Set retention period

Sets the retention period for records in the audit log. The retention period can be set to a maximum of 20 years.

Usage:

import { AuditApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new AuditApi(config).setRetentionPeriod({
  RetentionPeriod: { ... }
});

---

The ContentApi object

createContent() - Create content

Creates a new piece of content or publishes an existing draft.

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).createContent({
  status: string
  ContentCreate: { ... }
});

deleteContent() - Delete content

Moves a piece of content to the space's trash or purges it from the trash, depending on the content's type and status:

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).deleteContent({ ...args });

getContent() - Get content

Returns all content in a Confluence instance.

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).getContent({ ...args });

getContentById() - Get content by ID

Returns a single piece of content, like a page or a blog post.

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).getContentById({ ...args });

getHistoryForContent() - Get history for content

Returns the most recent update for a piece of content.

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).getHistoryForContent({ ...args });

getMacroBodyByMacroId() - Get macro body by macro ID

Returns the body of a macro in storage format, for the given macro ID. This includes information like the name of the macro, the body of the macro, and any macro parameters. This method is mainly used by Cloud apps.

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).getMacroBodyByMacroId({ ...args });

searchContentByCQL() - Search content by CQL

Returns the list of content that matches a Confluence Query Language (CQL) query. For information on CQL, see: Advanced searching using CQL.

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).searchContentByCQL({ ...args });

updateContent() - Update content

Updates a piece of content. Use this method to update the title or body of a piece of content, change the status, change the parent page, and more.

Usage:

import { ContentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentApi(config).updateContent({
  id: string
  status: string
  conflictPolicy: string
  ContentUpdate: { ... }
});

---

The ContentBlueprintApi object

publishLegacyDraft() - Publish legacy draft

Publishes a legacy draft of a page created from a blueprint. Legacy drafts will eventually be removed in favor of shared drafts. For now, this method works the same as Publish shared draft.

Usage:

import { ContentBlueprintApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentBlueprintApi(config).publishLegacyDraft({
  draftId: string
  status: string
  ContentBlueprintDraft: { ... }
});

publishSharedDraft() - Publish shared draft

Publishes a shared draft of a page created from a blueprint.

Usage:

import { ContentBlueprintApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentBlueprintApi(config).publishSharedDraft({
  draftId: string
  status: string
  ContentBlueprintDraft: { ... }
});

---

The ContentIdChildApi object

getAttachments() - Get attachments

Returns the attachments for a piece of content.

Usage:

import { ContentIdChildApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildApi(config).getAttachments({ ...args });

getContentChildren() - Get content children

Returns a map of the direct children of a piece of content. A piece of content has different types of child content, depending on its type. These are the default parent-child content type relationships:

Usage:

import { ContentIdChildApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildApi(config).getContentChildren({ ...args });

getContentChildrenByType() - Get content children by type

Returns all children of a given type, for a piece of content. A piece of content has different types of child content, depending on its type:

Usage:

import { ContentIdChildApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildApi(config).getContentChildrenByType({ ...args });

getContentComments() - Get content comments

Returns the comments on a piece of content.

Usage:

import { ContentIdChildApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildApi(config).getContentComments({ ...args });

---

The ContentIdChildAttachmentApi object

createAttachments() - Create attachment

Adds an attachment to a piece of content. This method only adds a new attachment. If you want to update an existing attachment, use Create or update attachments.

Usage:

import { ContentIdChildAttachmentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildAttachmentApi(config).createAttachments({
  id: string
  status: string
  createAttachments: { ... }
});

createOrUpdateAttachments() - Create or update attachment

Adds an attachment to a piece of content. If the attachment already exists for the content, then the attachment is updated (i.e. a new version of the attachment is created).

Usage:

import { ContentIdChildAttachmentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildAttachmentApi(config).createOrUpdateAttachments({
  id: string
  status: string
  createAttachments: { ... }
});

updateAttachmentData() - Update attachment data

Updates the binary data of an attachment, given the attachment ID, and optionally the comment and the minor edit field.

Usage:

import { ContentIdChildAttachmentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildAttachmentApi(config).updateAttachmentData({
  id: string
  attachmentId: string
  createAttachments: { ... }
});

updateAttachmentProperties() - Update attachment properties

Updates the attachment properties, i.e. the non-binary data of an attachment like the filename, media-type, comment, and parent container.

Usage:

import { ContentIdChildAttachmentApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdChildAttachmentApi(config).updateAttachmentProperties({
  id: string
  attachmentId: string
  AttachmentUpdate: { ... }
});

---

The ContentIdDescendantApi object

descendantsOfType() - Get content descendants by type

Returns all descendants of a given type, for a piece of content. This is similar to Get content children by type, except that this method returns child pages at all levels, rather than just the direct child pages.

Usage:

import { ContentIdDescendantApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdDescendantApi(config).descendantsOfType({ ...args });

getContentDescendants() - Get content descendants

Returns a map of the descendants of a piece of content. This is similar to Get content children, except that this method returns child pages at all levels, rather than just the direct child pages.

Usage:

import { ContentIdDescendantApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdDescendantApi(config).getContentDescendants({ ...args });

---

The ContentIdLabelApi object

addLabelsToContent() - Add labels to content

Adds labels to a piece of content. Does not modify the existing labels.

Usage:

import { ContentIdLabelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdLabelApi(config).addLabelsToContent({
  id: string
  LabelCreateArray: { ... }
});

getLabelsForContent() - Get labels for content

Returns the labels on a piece of content.

Usage:

import { ContentIdLabelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdLabelApi(config).getLabelsForContent({ ...args });

removeLabelFromContent() - Remove label from content

Removes a label from a piece of content. This is similar to Remove label from content using query parameter except that the label name is specified via a path parameter.

Usage:

import { ContentIdLabelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdLabelApi(config).removeLabelFromContent({ ...args });

removeLabelFromContentUsingQueryParameter() - Remove label from content using query parameter

Removes a label from a piece of content. This is similar to Remove label from content except that the label name is specified via a query parameter.

Usage:

import { ContentIdLabelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdLabelApi(config).removeLabelFromContentUsingQueryParameter({ ...args });

---

The ContentIdNotificationApi object

getWatchesForPage() - Get watches for page

Returns the watches for a page. A user that watches a page will receive receive notifications when the page is updated.

Usage:

import { ContentIdNotificationApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdNotificationApi(config).getWatchesForPage({ ...args });

getWatchesForSpace() - Get watches for space

Returns all space watches for the space that the content is in. A user that watches a space will receive receive notifications when any content in the space is updated.

Usage:

import { ContentIdNotificationApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdNotificationApi(config).getWatchesForSpace({ ...args });

---

The ContentIdPropertyApi object

createContentProperty() - Create content property

Creates a property for an existing piece of content. For more information about content properties, see Confluence entity properties.

Usage:

import { ContentIdPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdPropertyApi(config).createContentProperty({
  id: string
  ContentPropertyCreate: { ... }
});

createContentPropertyForKey() - Create content property for key

Creates a property for an existing piece of content. For more information about content properties, see Confluence entity properties.

Usage:

import { ContentIdPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdPropertyApi(config).createContentPropertyForKey({
  id: string
  key: string
  ContentPropertyCreateNoKey: { ... }
});

deleteContentProperty() - Delete content property

Deletes a content property. For more information about content properties, see Confluence entity properties.

Usage:

import { ContentIdPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdPropertyApi(config).deleteContentProperty({ ...args });

getContentProperties() - Get content properties

Returns the properties for a piece of content. For more information about content properties, see Confluence entity properties.

Usage:

import { ContentIdPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdPropertyApi(config).getContentProperties({ ...args });

getContentProperty() - Get content property

Returns a content property for a piece of content. For more information, see Confluence entity properties.

Usage:

import { ContentIdPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdPropertyApi(config).getContentProperty({ ...args });

updateContentProperty() - Update content property

Updates an existing content property. This method will also create a new property for a piece of content, if the property key does not exist and the property version is 1. For more information about content properties, see Confluence entity properties.

Usage:

import { ContentIdPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdPropertyApi(config).updateContentProperty({
  id: string
  key: string
  ContentPropertyUpdate: { ... }
});

---

The ContentIdRestrictionApi object

addGroupToContentRestriction() - Add group to content restriction

Adds a group to a content restriction. That is, grant read or update permission to the group for a piece of content.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).addGroupToContentRestriction({ ...args });

addRestrictions() - Add restrictions

Adds restrictions to a piece of content. Note, this does not change any existing restrictions on the content.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).addRestrictions({
  id: string
  expand: array
  ContentRestrictionUpdateArray: { ... }
});

addUserToContentRestriction() - Add user to content restriction

Adds a user to a content restriction. That is, grant read or update permission to the user for a piece of content.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).addUserToContentRestriction({ ...args });

deleteRestrictions() - Delete restrictions

Removes all restrictions (read and update) on a piece of content.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).deleteRestrictions({ ...args });

getContentRestrictionStatusForGroup() - Get content restriction status for group

Returns whether the specified content restriction applies to a group. For example, if a page with id=123 has a read restriction for the admins group, the following request will return true:

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).getContentRestrictionStatusForGroup({ ...args });

getContentRestrictionStatusForUser() - Get content restriction status for user

Returns whether the specified content restriction applies to a user. For example, if a page with id=123 has a read restriction for a user with an account ID of 384093:32b4d9w0-f6a5-3535-11a3-9c8c88d10192, the following request will return true:

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).getContentRestrictionStatusForUser({ ...args });

getRestrictions() - Get restrictions

Returns the restrictions on a piece of content.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).getRestrictions({ ...args });

getRestrictionsByOperation() - Get restrictions by operation

Returns restrictions on a piece of content by operation. This method is similar to Get restrictions except that the operations are properties of the return object, rather than items in a results array.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).getRestrictionsByOperation({ ...args });

getRestrictionsForOperation() - Get restrictions for operation

Returns the restictions on a piece of content for a given operation (read or update).

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).getRestrictionsForOperation({ ...args });

removeGroupFromContentRestriction() - Remove group from content restriction

Removes a group from a content restriction. That is, remove read or update permission for the group for a piece of content.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).removeGroupFromContentRestriction({ ...args });

removeUserFromContentRestriction() - Remove user from content restriction

Removes a group from a content restriction. That is, remove read or update permission for the group for a piece of content.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).removeUserFromContentRestriction({ ...args });

updateRestrictions() - Update restrictions

Updates restrictions for a piece of content. This removes the existing restrictions and replaces them with the restrictions in the request.

Usage:

import { ContentIdRestrictionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdRestrictionApi(config).updateRestrictions({
  id: string
  expand: array
  ContentRestrictionUpdateArray: { ... }
});

---

The ContentIdVersionApi object

deleteContentVersion() - Delete content version

Delete a historical version. This does not delete the changes made to the content in that version, rather the changes for the deleted version are rolled up into the next version. Note, you cannot delete the current version.

Usage:

import { ContentIdVersionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdVersionApi(config).deleteContentVersion({ ...args });

getContentVersion() - Get content version

Returns a version for a piece of content.

Usage:

import { ContentIdVersionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdVersionApi(config).getContentVersion({ ...args });

getContentVersions() - Get content versions

Returns the versions for a piece of content in descending order.

Usage:

import { ContentIdVersionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdVersionApi(config).getContentVersions({ ...args });

restoreContentVersion() - Restore content version

Restores a historical version to be the latest version. That is, a new version is created with the content of the historical version.

Usage:

import { ContentIdVersionApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentIdVersionApi(config).restoreContentVersion({
  id: string
  expand: array
  VersionRestore: { ... }
});

---

The ContentbodyConvertToApi object

convertContentBody() - Convert content body

Converts a content body from one format to another format.

Usage:

import { ContentbodyConvertToApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new ContentbodyConvertToApi(config).convertContentBody({
  to: string
  spaceKeyContext: string
  contentIdContext: string
  embeddedContentRender: string
  ContentBodyCreate: { ... }
});

---

The DefaultApi object

copyPageHierarchy() - Copy page hierarchy

Copy page hierarchy allows the copying of an entire hierarchy of pages and their associated properties, permissions and attachments. The id path parameter refers to the content id of the page to copy, and the new parent of this copied page is defined using the destinationPageId in the request body. The titleOptions object defines the rules of renaming page titles during the copy; for example, search and replace can be used in conjunction to rewrite the copied page titles.

Usage:

import { DefaultApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new DefaultApi(config).copyPageHierarchy({
  id: string
  CopyPageHierarchy: { ... }
});

cqlPDCleaner() - Convert user identifiers to account IDs in CQL queries

Converts one or more CQL queries with user identifiers (username or user key) to equivalent CQL queries with account IDs.

Usage:

import { DefaultApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new DefaultApi(config).cqlPDCleaner({
  CQLPersonalDataMigrationRequest: { ... }
});

---

The GroupApi object

getGroup() - Get group

Returns a user group for a given group name.

Usage:

import { GroupApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new GroupApi(config).getGroup({ ...args });

getGroupMembers() - Get group members

Returns the users that are members of a group.

Usage:

import { GroupApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new GroupApi(config).getGroupMembers({ ...args });

getGroups() - Get groups

Returns all user groups. The returned groups are ordered alphabetically in ascending order by group name.

Usage:

import { GroupApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new GroupApi(config).getGroups({ ...args });

---

The LongtaskApi object

getTask() - Get long-running task

Returns information about an active long-running task (e.g. space export), such as how long it has been running and the percentage of the task that has completed.

Usage:

import { LongtaskApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new LongtaskApi(config).getTask({ ...args });

getTasks() - Get long-running tasks

Returns information about all active long-running tasks (e.g. space export), such as how long each task has been running and the percentage of each task that has completed.

Usage:

import { LongtaskApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new LongtaskApi(config).getTasks({ ...args });

---

The RelationApi object

createRelationship() - Create relationship

Creates a relationship between two entities (user, space, content). The 'favourite' relationship is supported by default, but you can use this method to create any type of relationship between two entities.

Usage:

import { RelationApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new RelationApi(config).createRelationship({ ...args });

findSourcesForTarget() - Find target entities related to a source entity

Returns all target entities that have a particular relationship to the source entity. Note, relationships are one way.

Usage:

import { RelationApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new RelationApi(config).findSourcesForTarget({ ...args });

findTargetFromSource() - Find target entities related to a source entity

Returns all target entities that have a particular relationship to the source entity. Note, relationships are one way.

Usage:

import { RelationApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new RelationApi(config).findTargetFromSource({ ...args });

---

The SearchApi object

search() - Search

Searches for content using the Confluence Query Language (CQL)

Usage:

import { SearchApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SearchApi(config).search({ ...args });

---

The SearchUserApi object

---

The SettingsApi object

getSystemInfo() - Get system info

Returns the system information for the Confluence Cloud tenant. This information is used by Atlassian.

Usage:

import { SettingsApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsApi(config).getSystemInfo({ ...args });

---

The SettingsLookandfeelApi object

getLookAndFeelSettings() - Get look and feel settings

Returns the look and feel settings for the site or a single space. This includes attributes such as the color scheme, padding, and border radius.

Usage:

import { SettingsLookandfeelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsLookandfeelApi(config).getLookAndFeelSettings({ ...args });

resetLookAndFeelSettings() - Reset look and feel settings

Resets the custom look and feel settings for the site or a single space. This changes the values of the custom settings to be the same as the default settings. It does not change which settings (default or custom) are selected. Note, the default space settings are inherited from the current global settings.

Usage:

import { SettingsLookandfeelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsLookandfeelApi(config).resetLookAndFeelSettings({ ...args });

setLookAndFeelSettings() - Set look and feel settings

Sets the look and feel settings to either the default settings or the custom settings, for the site or a single space. Note, the default space settings are inherited from the current global settings.

Usage:

import { SettingsLookandfeelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsLookandfeelApi(config).setLookAndFeelSettings({
  spaceKey: string
  LookAndFeelType: { ... }
});

updateLookAndFeelSettings() - Update look and feel settings

Updates the look and feel settings for the site or for a single space. If custom settings exist, they are updated. If no custom settings exist, then a set of custom settings is created.

Usage:

import { SettingsLookandfeelApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsLookandfeelApi(config).updateLookAndFeelSettings({
  spaceKey: string
  LookAndFeel: { ... }
});

---

The SettingsThemeApi object

getGlobalTheme() - Get global theme

Returns the globally assigned theme.

Usage:

import { SettingsThemeApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsThemeApi(config).getGlobalTheme({ ...args });

getTheme() - Get theme

Returns a theme. This includes information about the theme name, description, and icon.

Usage:

import { SettingsThemeApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsThemeApi(config).getTheme({ ...args });

getThemes() - Get themes

Returns all themes, not including the default theme.

Usage:

import { SettingsThemeApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SettingsThemeApi(config).getThemes({ ...args });

---

The SpaceApi object

createPrivateSpace() - Create private space

Creates a new space that is only visible to the creator. This method is the same as the Create space method with permissions set to the current user only. Note, currently you cannot set space labels when creating a space.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).createPrivateSpace({
  SpacePrivateCreate: { ... }
});

createSpace() - Create space

Creates a new space. Note, currently you cannot set space labels when creating a space.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).createSpace({
  SpaceCreate: { ... }
});

deleteSpace() - Delete space

Deletes a space. Note, the space will be deleted in a long running task. Therefore, the space may not be deleted yet when this method has returned. Clients should poll the status link that is returned in the response until the task completes.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).deleteSpace({ ...args });

getContentByTypeForSpace() - Get content by type for space

Returns all content of a given type, in a space. The returned content is ordered by content ID in ascending order.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).getContentByTypeForSpace({ ...args });

getContentForSpace() - Get content for space

Returns all content in a space. The returned content is grouped by type (pages then blogposts), then ordered by content ID in ascending order.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).getContentForSpace({ ...args });

getSpace() - Get space

Returns a space. This includes information like the name, description, and permissions, but not the content in the space.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).getSpace({ ...args });

getSpaceSettings() - Get space settings

Returns the settings of a space. Currently only the routeOverrideEnabled setting can be returned.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).getSpaceSettings({ ...args });

getSpaces() - Get spaces

Returns all spaces. The returned spaces are ordered alphabetically in ascending order by space key.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).getSpaces({ ...args });

updateSpace() - Update space

Updates the name, description, or homepage of a space.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).updateSpace({
  spaceKey: string
  SpaceUpdate: { ... }
});

updateSpaceSettings() - Update space settings

Updates the settings for a space. Currently only the routeOverrideEnabled setting can be updated.

Usage:

import { SpaceApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceApi(config).updateSpaceSettings({
  spaceKey: string
  SpaceSettingsUpdate: { ... }
});

---

The SpaceSpaceKeyPropertyApi object

createSpaceProperty() - Create space property

Creates a new space property.

Usage:

import { SpaceSpaceKeyPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyPropertyApi(config).createSpaceProperty({
  spaceKey: string
  SpacePropertyCreate: { ... }
});

createSpacePropertyForKey() - Create space property for key

Creates a new space property. This is the same as POST /space/{spaceKey}/property but the key for the property is passed as a path parameter, rather than in the request body.

Usage:

import { SpaceSpaceKeyPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyPropertyApi(config).createSpacePropertyForKey({
  spaceKey: string
  key: string
  SpacePropertyCreateNoKey: { ... }
});

deleteSpaceProperty() - Delete space property

Deletes a space property.

Usage:

import { SpaceSpaceKeyPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyPropertyApi(config).deleteSpaceProperty({ ...args });

getSpaceProperties() - Get space properties

Returns all properties for the given space. Space properties are a key-value storage associated with a space.

Usage:

import { SpaceSpaceKeyPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyPropertyApi(config).getSpaceProperties({ ...args });

getSpaceProperty() - Get space property

Returns a space property.

Usage:

import { SpaceSpaceKeyPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyPropertyApi(config).getSpaceProperty({ ...args });

updateSpaceProperty() - Update space property

Updates a space property. Note, you cannot update the key of a space property, only the value.

Usage:

import { SpaceSpaceKeyPropertyApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyPropertyApi(config).updateSpaceProperty({
  spaceKey: string
  key: string
  SpacePropertyUpdate: { ... }
});

---

The SpaceSpaceKeyThemeApi object

getSpaceTheme() - Get space theme

Returns the theme selected for a space, if one is set. If no space theme is set, this means that the space is inheriting the global look and feel settings.

Usage:

import { SpaceSpaceKeyThemeApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyThemeApi(config).getSpaceTheme({ ...args });

resetSpaceTheme() - Reset space theme

Resets the space theme. This means that the space will inherit the global look and feel settings

Usage:

import { SpaceSpaceKeyThemeApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyThemeApi(config).resetSpaceTheme({ ...args });

setSpaceTheme() - Set space theme

Sets the theme for a space. Note, if you want to reset the space theme to the default Confluence theme, use the 'Reset space theme' method instead of this method.

Usage:

import { SpaceSpaceKeyThemeApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyThemeApi(config).setSpaceTheme({
  spaceKey: string
  ThemeUpdate: { ... }
});

---

The SpaceSpaceKeyWatchApi object

getWatchersForSpace() - Returns a list of watchers of a space

Returns a list of watchers of a space

Usage:

import { SpaceSpaceKeyWatchApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new SpaceSpaceKeyWatchApi(config).getWatchersForSpace({ ...args });

---

The TemplateApi object

createContentTemplate() - Create content template

Creates a new content template. Note, blueprint templates cannot be created via the REST API.

Usage:

import { TemplateApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new TemplateApi(config).createContentTemplate({
  ContentTemplateCreate: { ... }
});

getBlueprintTemplates() - Get blueprint templates

Returns all templates provided by blueprints. Use this method to retrieve all global blueprint templates or all blueprint templates in a space.

Usage:

import { TemplateApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new TemplateApi(config).getBlueprintTemplates({ ...args });

getContentTemplate() - Get content template

Returns a content template. This includes information about template, like the name, the space or blueprint that the template is in, the body of the template, and more.

Usage:

import { TemplateApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new TemplateApi(config).getContentTemplate({ ...args });

getContentTemplates() - Get content templates

Returns all content templates. Use this method to retrieve all global content templates or all content templates in a space.

Usage:

import { TemplateApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new TemplateApi(config).getContentTemplates({ ...args });

removeTemplate() - Remove template

Deletes a template. This results in different actions depending on the type of template:

Usage:

import { TemplateApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new TemplateApi(config).removeTemplate({ ...args });

updateContentTemplate() - Update content template

Updates a content template. Note, blueprint templates cannot be updated via the REST API.

Usage:

import { TemplateApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new TemplateApi(config).updateContentTemplate({
  ContentTemplateUpdate: { ... }
});

---

The UserApi object

addContentWatcher() - Add content watcher

Adds a user as a watcher to a piece of content. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).addContentWatcher({ ...args });

addLabelWatcher() - Add label watcher

Adds a user as a watcher to a label. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).addLabelWatcher({ ...args });

addSpaceWatcher() - Add space watcher

Adds a user as a watcher to a space. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).addSpaceWatcher({ ...args });

getAnonymousUser() - Get anonymous user

Returns information about how anonymous users are represented, like the profile picture and display name.

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).getAnonymousUser({ ...args });

getBulkUserLookup() - Get multiple users using ids

Returns user details for the ids provided in request.

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).getBulkUserLookup({ ...args });

getBulkUserMigration() - Get accountIds for users

Returns the accountIds for the users specified in the key or username parameters. Note that multiple key and username parameters can be specified.

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).getBulkUserMigration({ ...args });

getContentWatchStatus() - Get content watch status

Returns whether a user is watching a piece of content. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).getContentWatchStatus({ ...args });

getCurrentUser() - Get current user

Returns the currently logged-in user. This includes information about the user, like the display name, userKey, account ID, profile picture, and more.

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).getCurrentUser({ ...args });

getGroupMembershipsForUser() - Get group memberships for user

Returns the groups that a user is a member of.

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).getGroupMembershipsForUser({ ...args });

getUser() - Get user

Returns a user. This includes information about the user, like the display name, userKey, account ID, profile picture, and more.

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).getUser({ ...args });

isWatchingLabel() - Get label watch status

Returns whether a user is watching a label. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).isWatchingLabel({ ...args });

isWatchingSpace() - Get space watch status

Returns whether a user is watching a space. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).isWatchingSpace({ ...args });

removeContentWatcher() - Remove content watcher

Removes a user as a watcher from a piece of content. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).removeContentWatcher({ ...args });

removeLabelWatcher() - Remove label watcher

Removes a user as a watcher from a label. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).removeLabelWatcher({ ...args });

removeSpaceWatch() - Remove space watch

Removes a user as a watcher from a space. Choose the user by doing one of the following:

Usage:

import { UserApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserApi(config).removeSpaceWatch({ ...args });

---

The UserEmailApi object

getPrivacyUnsafeUserEmail() - Get a user's email

Returns a user's email address. This API is only available to apps approved by Atlassian, according to these guidelines.

Usage:

import { UserEmailApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserEmailApi(config).getPrivacyUnsafeUserEmail({ ...args });

---

The UserEmailBulkApi object

getPrivacyUnsafeUserEmailBulk() - Bulk fetch of users' email addresses

Returns user email addresses for a set of accountIds. This API is only available to apps approved by Atlassian, according to these guidelines.

Usage:

import { UserEmailBulkApi, Configuration } from 'fetch-confluence';

const config: Configuration = new Configuration({
  fetchApi: yourFetchClient,
  basePath: "<your base path>"
});

const responsePromise = new UserEmailBulkApi(config).getPrivacyUnsafeUserEmailBulk({ ...args });

References

CreateAttachmentsPayload

{
  "title": "CreateAttachmentsPayload",
  "type": "object",
  "properties": {
    "file": {
      "description": "The relative location and name of the attachment to be added to\nthe content.",
      "type": "string",
      "format": "binary"
    },
    "comment": {
      "description": "The comment for the attachment that is being added.\nIf you specify a comment, then every file must have a comment and\nthe comments must be in the same order as the files. Alternatively,\ndon't specify any comments.",
      "type": "string",
      "format": "binary"
    },
    "minorEdit": {
      "description": "If `minorEdits` is set to 'true', no notification email or activity stream\nwill be generated when the attachment is added to the content.",
      "type": "string",
      "format": "binary"
    }
  },
  "required": [
    "file",
    "minorEdit"
  ]
}

AccountIdEmailRecord

{
  "type": "object",
  "required": [
    "accountId",
    "email"
  ],
  "additionalProperties": false,
  "properties": {
    "accountId": {
      "type": "string"
    },
    "email": {
      "type": "string"
    }
  }
}

AccountIdEmailRecordArray

{
  "type": "array",
  "items": {
    "$ref": "#/components/schemas/AccountIdEmailRecord"
  }
}

AffectedObject

{
  "type": "object",
  "required": [
    "name",
    "objectType"
  ],
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string"
    },
    "objectType": {
      "type": "string"
    }
  }
}

AttachmentUpdate

{
  "type": "object",
  "required": [
    "version",
    "id",
    "type"
  ],
  "additionalProperties": false,
  "properties": {
    "version": {
      "type": "object",
      "required": [
        "number"
      ],
      "additionalProperties": false,
      "description": "The attachment version. Set this to the current version number of the\nattachment. Note, the version number only needs to be incremented when\nupdating the actual attachment, not its properties.",
      "properties": {
        "number": {
          "type": "integer",
          "format": "int32",
          "description": "The version number."
        }
      }
    },
    "id": {
      "type": "string",
      "description": "The ID of the attachment to be updated."
    },
    "type": {
      "type": "string",
      "description": "Set this to `attachment`.",
      "enum": [
        "attachment"
      ]
    },
    "title": {
      "type": "string",
      "description": "The updated name of the attachment.",
      "maxLength": 255
    },
    "metadata": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "mediaType": {
          "type": "string",
          "description": "The media type of the attachment, e.g. 'img/jpg'."
        },
        "comment": {
          "type": "string",
          "description": "The comment for this update."
        }
      }
    },
    "container": {
      "type": "object",
      "description": "The new content to attach the attachment to.",
      "required": [
        "id",
        "type"
      ],
      "additionalProperties": false,
      "properties": {
        "id": {
          "type": "string",
          "description": "The `id` of the parent content."
        },
        "type": {
          "type": "string",
          "description": "The content type. You can only attach attachments to content\nof type: `page`, `blogpost`."
        }
      }
    }
  },
  "title": "AttachmentUpdate"
}

AuditRecord

{
  "type": "object",
  "required": [
    "author",
    "remoteAddress",
    "creationDate",
    "summary",
    "description",
    "category",
    "sysAdmin",
    "affectedObject",
    "changedValues",
    "associatedObjects"
  ],
  "additionalProperties": false,
  "properties": {
    "author": {
      "type": "object",
      "required": [
        "type",
        "displayName",
        "operations",
        "username",
        "userKey"
      ],
      "additionalProperties": false,
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "user"
          ],
          "default": "user"
        },
        "displayName": {
          "type": "string"
        },
        "operations": {
          "type": "object",
          "default": {}
        },
        "username": {
          "type": "string"
        },
        "userKey": {
          "type": "string"
        }
      }
    },
    "remoteAddress": {
      "type": "string"
    },
    "creationDate": {
      "type": "integer",
      "description": "The creation date-time of the audit record, as a timestamp.",
      "format": "int64"
    },
    "summary": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "category": {
      "type": "string"
    },
    "sysAdmin": {
      "type": "boolean"
    },
    "affectedObject": {
      "$ref": "#/components/schemas/AffectedObject"
    },
    "changedValues": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ChangedValue"
      }
    },
    "associatedObjects": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/AffectedObject"
      }
    }
  }
}

AuditRecordArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/AuditRecord"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

AuditRecordCreate

{
  "type": "object",
  "required": [
    "remoteAddress"
  ],
  "additionalProperties": false,
  "properties": {
    "author": {
      "type": "object",
      "description": "The user that actioned the event. If `author` is not specified, then all\n`author` properties will be set to null/empty, except for `type` which\nwill be set to 'user'.",
      "required": [
        "type"
      ],
      "additionalProperties": false,
      "properties": {
        "type": {
          "type": "string",
          "description": "Set to 'user'.",
          "enum": [
            "user"
          ],
          "default": "user"
        },
        "displayName": {
          "type": "string",
          "description": "The name that is displayed on the audit log in the Confluence UI."
        },
        "operations": {
          "type": "object",
          "description": "Always defaults to null.",
          "default": {}
        },
        "username": {
          "type": "string",
          "description": "The username of the user that actioned the event."
        },
        "userKey": {
          "type": "string",
          "description": "The userKey of the user that actioned the event."
        }
      }
    },
    "remoteAddress": {
      "type": "string",
      "description": "The IP address of the computer where the event was initiated from."
    },
    "creationDate": {
      "type": "integer",
      "description": "The creation date-time of the audit record, as a timestamp. This is converted\nto a date-time display in the Confluence UI. If the `creationDate` is not\nspecified, then it will be set to the timestamp for the current date-time.",
      "format": "int64"
    },
    "summary": {
      "type": "string",
      "description": "The summary of the event, which is displayed in the 'Change' column on\nthe audit log in the Confluence UI."
    },
    "description": {
      "type": "string",
      "description": "A long description of the event, which is displayed in the 'Description'\nfield on the audit log in the Confluence UI."
    },
    "category": {
      "type": "string",
      "description": "The category of the event, which is displayed in the 'Event type' column\non the audit log in the Confluence UI."
    },
    "sysAdmin": {
      "type": "boolean",
      "description": "Indicates whether the event was actioned by a system administrator.",
      "default": false
    },
    "affectedObject": {
      "$ref": "#/components/schemas/AffectedObject"
    },
    "changedValues": {
      "type": "array",
      "description": "The values that were changed in the event.",
      "items": {
        "$ref": "#/components/schemas/ChangedValue"
      }
    },
    "associatedObjects": {
      "type": "array",
      "description": "Objects that were associated with the event. For example, if the event\nwas a space permission change then the associated object would be the\nspace.",
      "items": {
        "$ref": "#/components/schemas/AffectedObject"
      }
    }
  },
  "title": "AuditRecordCreate"
}

BlueprintTemplate

{
  "type": "object",
  "required": [
    "templateId",
    "originalTemplate",
    "referencingBlueprint",
    "name",
    "description",
    "labels",
    "templateType",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "templateId": {
      "type": "string"
    },
    "originalTemplate": {
      "type": "object",
      "required": [
        "pluginKey",
        "moduleKey"
      ],
      "additionalProperties": false,
      "properties": {
        "pluginKey": {
          "type": "string"
        },
        "moduleKey": {
          "type": "string"
        }
      }
    },
    "referencingBlueprint": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "labels": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Label"
      }
    },
    "templateType": {
      "type": "string"
    },
    "body": {
      "$ref": "#/components/schemas/ContentBody"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "body": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

BlueprintTemplateArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/BlueprintTemplate"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ButtonLookAndFeel

{
  "type": "object",
  "required": [
    "backgroundColor",
    "color"
  ],
  "additionalProperties": false,
  "properties": {
    "backgroundColor": {
      "type": "string"
    },
    "color": {
      "type": "string"
    }
  }
}

Breadcrumb

{
  "type": "object",
  "required": [
    "label",
    "url",
    "separator"
  ],
  "additionalProperties": false,
  "properties": {
    "label": {
      "type": "string"
    },
    "url": {
      "type": "string"
    },
    "separator": {
      "type": "string"
    }
  }
}

ChangedValue

{
  "type": "object",
  "required": [
    "name",
    "oldValue",
    "newValue"
  ],
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string"
    },
    "oldValue": {
      "type": "string"
    },
    "newValue": {
      "type": "string"
    }
  }
}

Container

{
  "type": "object",
  "description": "Container for content. This can be either a space (containing a page or blogpost)\nor a page/blog post (containing an attachment or comment)",
  "additionalProperties": true
}

ContainerLookAndFeel

{
  "type": "object",
  "required": [
    "background",
    "backgroundColor",
    "backgroundImage",
    "backgroundSize",
    "padding",
    "borderRadius"
  ],
  "additionalProperties": false,
  "properties": {
    "background": {
      "type": "string"
    },
    "backgroundColor": {
      "type": "string"
    },
    "backgroundImage": {
      "type": "string"
    },
    "backgroundSize": {
      "type": "string"
    },
    "padding": {
      "type": "string"
    },
    "borderRadius": {
      "type": "string"
    }
  }
}

ContainerSummary

{
  "type": "object",
  "required": [
    "title",
    "displayUrl"
  ],
  "additionalProperties": false,
  "properties": {
    "title": {
      "type": "string"
    },
    "displayUrl": {
      "type": "string"
    }
  }
}

Content

{
  "type": "object",
  "description": "Base object for all content types.",
  "required": [
    "id",
    "type",
    "status",
    "title",
    "_expandable"
  ],
  "additionalProperties": true,
  "properties": {
    "id": {
      "type": "string"
    },
    "type": {
      "type": "string"
    },
    "status": {
      "type": "string"
    },
    "title": {
      "type": "string"
    },
    "space": {
      "$ref": "#/components/schemas/Space"
    },
    "history": {
      "$ref": "#/components/schemas/ContentHistory"
    },
    "version": {
      "$ref": "#/components/schemas/Version"
    },
    "ancestors": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Content"
      }
    },
    "operations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/OperationCheckResult"
      }
    },
    "children": {
      "$ref": "#/components/schemas/ContentChildren"
    },
    "childTypes": {
      "$ref": "#/components/schemas/ContentChildType"
    },
    "descendants": {
      "$ref": "#/components/schemas/ContentChildren"
    },
    "container": {
      "$ref": "#/components/schemas/Container"
    },
    "body": {
      "type": "object",
      "required": [
        "_expandable"
      ],
      "minProperties": 1,
      "maxProperties": 1,
      "additionalProperties": false,
      "properties": {
        "view": {
          "$ref": "#/components/schemas/ContentBody"
        },
        "export_view": {
          "$ref": "#/components/schemas/ContentBody"
        },
        "styled_view": {
          "$ref": "#/components/schemas/ContentBody"
        },
        "storage": {
          "$ref": "#/components/schemas/ContentBody"
        },
        "editor2": {
          "$ref": "#/components/schemas/ContentBody"
        },
        "anonymous_export_view": {
          "$ref": "#/components/schemas/ContentBody"
        },
        "_expandable": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "editor": {
              "type": "string"
            },
            "view": {
              "type": "string"
            },
            "export_view": {
              "type": "string"
            },
            "styled_view": {
              "type": "string"
            },
            "storage": {
              "type": "string"
            },
            "editor2": {
              "type": "string"
            },
            "anonymous_export_view": {
              "type": "string"
            }
          }
        }
      }
    },
    "restrictions": {
      "type": "object",
      "required": [
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "read": {
          "$ref": "#/components/schemas/ContentRestriction"
        },
        "update": {
          "$ref": "#/components/schemas/ContentRestriction"
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "childTypes": {
          "type": "string"
        },
        "container": {
          "type": "string"
        },
        "metadata": {
          "type": "string"
        },
        "operations": {
          "type": "string"
        },
        "children": {
          "type": "string"
        },
        "restrictions": {
          "type": "string"
        },
        "history": {
          "type": "string"
        },
        "ancestors": {
          "type": "string"
        },
        "body": {
          "type": "string"
        },
        "version": {
          "type": "string"
        },
        "descendants": {
          "type": "string"
        },
        "space": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Content"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentAttachment

{
  "description": "Representation of an attachment (content)",
  "allOf": [
    {
      "$ref": "#/components/schemas/Content"
    },
    {
      "type": "object",
      "required": [
        "metadata",
        "extensions",
        "_links"
      ],
      "properties": {
        "metadata": {
          "type": "object",
          "properties": {
            "mediaType": {
              "type": "string"
            }
          }
        },
        "extensions": {
          "type": "object",
          "properties": {
            "position": {
              "type": "integer",
              "format": "int32"
            }
          }
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      },
      "additionalProperties": false
    }
  ]
}

ContentBlogpost

{
  "description": "Representation of a blogpost (content)",
  "allOf": [
    {
      "$ref": "#/components/schemas/Content"
    },
    {
      "type": "object",
      "required": [
        "metadata",
        "_links"
      ],
      "properties": {
        "metadata": {
          "$ref": "#/components/schemas/ContentMetadata"
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      },
      "additionalProperties": false
    }
  ]
}

ContentBlueprintDraft

{
  "type": "object",
  "required": [
    "version",
    "title",
    "type"
  ],
  "additionalProperties": false,
  "properties": {
    "version": {
      "type": "object",
      "description": "The version for the new content.",
      "required": [
        "number"
      ],
      "additionalProperties": false,
      "properties": {
        "number": {
          "type": "integer",
          "format": "int32",
          "description": "The version number. Set this to `1`."
        }
      }
    },
    "title": {
      "type": "string",
      "description": "The title of the content. If you don't want to change the title,\nset this to the current title of the draft.",
      "maxLength": 255
    },
    "type": {
      "type": "string",
      "description": "The type of content. Set this to `page`.",
      "enum": [
        "page"
      ]
    },
    "status": {
      "type": "string",
      "description": "The status of the content. Set this to `current` or omit it altogether.",
      "enum": [
        "current"
      ],
      "default": "current"
    },
    "space": {
      "type": "object",
      "required": [
        "key"
      ],
      "description": "The space for the content.",
      "additionalProperties": false,
      "properties": {
        "key": {
          "type": "string",
          "format": "int32",
          "description": "The key of the space"
        }
      }
    },
    "ancestors": {
      "type": "array",
      "description": "The new ancestor (i.e. parent page) for the content. If you have\nspecified an ancestor, you must also specify a `space` property\nin the request body for the space that the ancestor is in.\n\nNote, if you specify more than one ancestor, the last ID in the array\nwill be selected as the parent page for the content.",
      "items": {
        "type": "object",
        "required": [
          "id"
        ],
        "additionalProperties": false,
        "properties": {
          "id": {
            "type": "string",
            "description": "The content ID of the ancestor."
          }
        }
      }
    }
  },
  "title": "ContentBlueprintDraft"
}

ContentBody

{
  "type": "object",
  "required": [
    "value",
    "representation",
    "_expandable"
  ],
  "additionalProperties": false,
  "properties": {
    "value": {
      "type": "string"
    },
    "representation": {
      "type": "string",
      "enum": [
        "view",
        "export_view",
        "styled_view",
        "storage",
        "editor2",
        "anonymous_export_view"
      ]
    },
    "embeddedContent": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/EmbeddedContent"
      }
    },
    "webresource": {
      "$ref": "#/components/schemas/WebResourceDependencies"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "content": {
          "type": "string"
        }
      }
    }
  }
}

ContentBodyCreate

{
  "type": "object",
  "description": "This object is used when creating or updating content.",
  "required": [
    "value",
    "representation"
  ],
  "additionalProperties": false,
  "properties": {
    "value": {
      "type": "string",
      "description": "The body of the content in the relevant format."
    },
    "representation": {
      "type": "string",
      "description": "The content format type. Set the value of this property to\nthe name of the format being used, e.g. 'storage'.",
      "enum": [
        "view",
        "export_view",
        "styled_view",
        "storage",
        "editor2",
        "anonymous_export_view"
      ]
    }
  },
  "title": "ContentBodyCreate"
}

ContentChildren

{
  "type": "object",
  "required": [
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "attachment": {
      "$ref": "#/components/schemas/ContentArray"
    },
    "comment": {
      "$ref": "#/components/schemas/ContentArray"
    },
    "page": {
      "$ref": "#/components/schemas/ContentArray"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "attachment": {
          "type": "string"
        },
        "comment": {
          "type": "string"
        },
        "page": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentChildType

{
  "type": "object",
  "description": "Shows whether a piece of content has attachments, comments, or child pages.\nNote, this doesn't actually contain the child objects.",
  "required": [
    "_expandable"
  ],
  "additionalProperties": false,
  "properties": {
    "attachment": {
      "type": "object",
      "required": [
        "value",
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "value": {
          "type": "boolean"
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    },
    "comment": {
      "type": "object",
      "required": [
        "value",
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "value": {
          "type": "boolean"
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    },
    "page": {
      "type": "object",
      "required": [
        "value",
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "value": {
          "type": "boolean"
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "all": {
          "type": "string"
        },
        "attachment": {
          "type": "string"
        },
        "comment": {
          "type": "string"
        },
        "page": {
          "type": "string"
        }
      }
    }
  }
}

ContentComment

{
  "description": "Representation of a comment (content)",
  "allOf": [
    {
      "$ref": "#/components/schemas/Content"
    },
    {
      "type": "object",
      "required": [
        "metadata",
        "extensions",
        "_links"
      ],
      "properties": {
        "metadata": {
          "$ref": "#/components/schemas/ContentMetadata"
        },
        "extensions": {
          "type": "object",
          "required": [
            "location"
          ],
          "properties": {
            "location": {
              "type": "string"
            },
            "inlineProperties": {
              "type": "object",
              "required": [
                "originalSelection",
                "markerRef"
              ],
              "properties": {
                "originalSelection": {
                  "type": "string"
                },
                "markerRef": {
                  "type": "string"
                }
              }
            },
            "resolution": {
              "type": "object",
              "properties": {
                "status": {
                  "type": "string"
                },
                "lastModifier": {
                  "type": "object",
                  "properties": {
                    "type": {
                      "type": "string"
                    },
                    "profilePicture": {
                      "$ref": "#/components/schemas/Icon"
                    },
                    "displayName": {
                      "type": "string"
                    },
                    "operations": {
                      "type": "array",
                      "items": {
                        "$ref": "#/components/schemas/OperationCheckResult"
                      }
                    }
                  }
                },
                "lastModifiedDate": {
                  "type": "string",
                  "format": "date-time"
                }
              }
            }
          }
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      },
      "additionalProperties": false
    }
  ]
}

ContentCreate

{
  "type": "object",
  "required": [
    "title",
    "type",
    "space",
    "body"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "The ID of the draft content. Required when publishing a draft."
    },
    "title": {
      "type": "string",
      "maxLength": 255
    },
    "type": {
      "type": "string",
      "description": "The type of the new content. Custom content types defined by apps are also supported.",
      "enum": [
        "page",
        "blogpost",
        "comment",
        "attachment"
      ]
    },
    "space": {
      "type": "object",
      "required": [
        "key"
      ],
      "description": "The space that the content is being created in.",
      "properties": {
        "key": {
          "type": "string",
          "description": "The key of the space."
        }
      }
    },
    "container": {
      "type": "object",
      "required": [
        "id",
        "type"
      ],
      "description": "The container that the content is being created in.",
      "properties": {
        "id": {
          "type": "string",
          "description": "The id of the container."
        },
        "type": {
          "type": "string",
          "description": "The type of the container."
        }
      }
    },
    "status": {
      "type": "string",
      "description": "The status of the new content.",
      "enum": [
        "current",
        "trashed",
        "historical",
        "draft"
      ],
      "default": "current"
    },
    "ancestors": {
      "type": "array",
      "description": "The parent content of the new content. Only one parent content\n`id` can be specified.",
      "items": {
        "type": "object",
        "required": [
          "id"
        ],
        "properties": {
          "id": {
            "type": "string",
            "description": "The `id` of the parent content."
          }
        }
      }
    },
    "body": {
      "type": "object",
      "description": "The body of the new content. Does not apply to attachments.\nOnly one body format should be specified as the property for\nthis object, e.g. `storage`.\n\nNote, `editor2` format is used by Atlassian only. `anonymous_export_view` is\nthe same as 'export_view' format but only content viewable by an anonymous\nuser is included.",
      "minProperties": 1,
      "maxProperties": 1,
      "additionalProperties": false,
      "properties": {
        "view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "export_view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "styled_view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "storage": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "editor2": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "anonymous_export_view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        }
      }
    }
  },
  "additionalProperties": false,
  "title": "ContentCreate"
}

ContentHistory

{
  "type": "object",
  "required": [
    "latest",
    "createdBy",
    "createdDate"
  ],
  "additionalProperties": false,
  "properties": {
    "latest": {
      "type": "boolean"
    },
    "createdBy": {
      "$ref": "#/components/schemas/User"
    },
    "createdDate": {
      "type": "string",
      "format": "date-time"
    },
    "lastUpdated": {
      "$ref": "#/components/schemas/Version"
    },
    "previousVersion": {
      "$ref": "#/components/schemas/Version"
    },
    "contributors": {
      "type": "object",
      "properties": {
        "publishers": {
          "$ref": "#/components/schemas/UsersUserKeys"
        }
      }
    },
    "nextVersion": {
      "$ref": "#/components/schemas/Version"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "lastUpdated": {
          "type": "string"
        },
        "previousVersion": {
          "type": "string"
        },
        "contributors": {
          "type": "string"
        },
        "nextVersion": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentId

{
  "type": "string"
}

ContentLookAndFeel

{
  "type": "object",
  "required": [
    "screen",
    "container",
    "header",
    "body"
  ],
  "properties": {
    "screen": {
      "$ref": "#/components/schemas/ScreenLookAndFeel"
    },
    "container": {
      "$ref": "#/components/schemas/ContainerLookAndFeel"
    },
    "header": {
      "$ref": "#/components/schemas/ContainerLookAndFeel"
    },
    "body": {
      "$ref": "#/components/schemas/ContainerLookAndFeel"
    }
  }
}

ContentMetadata

{
  "type": "object",
  "description": "Metadata object for page, blogpost, comment content",
  "properties": {
    "currentuser": {
      "type": "object",
      "properties": {
        "favourited": {
          "type": "object",
          "properties": {
            "isFavourite": {
              "type": "boolean"
            },
            "favouritedDate": {
              "type": "string",
              "format": "date-time"
            }
          }
        },
        "lastmodified": {
          "type": "object",
          "properties": {
            "version": {
              "$ref": "#/components/schemas/Version"
            },
            "friendlyLastModified": {
              "type": "string"
            }
          }
        },
        "lastcontributed": {
          "type": "object",
          "properties": {
            "status": {
              "type": "string"
            },
            "when": {
              "type": "string",
              "format": "date-time"
            }
          }
        },
        "viewed": {
          "type": "object",
          "properties": {
            "lastSeen": {
              "type": "string",
              "format": "date-time"
            },
            "friendlyLastSeen": {
              "type": "string"
            }
          }
        }
      }
    },
    "properties": {
      "$ref": "#/components/schemas/GenericLinks"
    },
    "frontend": {
      "type": "object"
    },
    "labels": {
      "$ref": "#/components/schemas/LabelArray"
    }
  },
  "additionalProperties": false
}

ContentPage

{
  "description": "Representation of a page (content)",
  "allOf": [
    {
      "$ref": "#/components/schemas/Content"
    },
    {
      "type": "object",
      "required": [
        "metadata",
        "extensions",
        "_links"
      ],
      "properties": {
        "metadata": {
          "$ref": "#/components/schemas/ContentMetadata"
        },
        "extensions": {
          "type": "object",
          "properties": {
            "position": {
              "type": "integer",
              "format": "int32"
            }
          }
        },
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      },
      "additionalProperties": false
    }
  ]
}

ContentProperty

{
  "type": "object",
  "required": [
    "id",
    "key",
    "value",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "id": {
      "type": "integer",
      "format": "int32"
    },
    "key": {
      "type": "string"
    },
    "value": {
      "type": "object",
      "description": "The value of the content property. This can be empty or a complex object.",
      "additionalProperties": true
    },
    "version": {
      "type": "object",
      "required": [
        "when",
        "message",
        "number",
        "minorEdit"
      ],
      "additionalProperties": false,
      "properties": {
        "when": {
          "type": "string",
          "format": "date-time"
        },
        "message": {
          "type": "string"
        },
        "number": {
          "type": "integer",
          "format": "int32"
        },
        "minorEdit": {
          "type": "boolean"
        }
      }
    },
    "content": {
      "$ref": "#/components/schemas/Content"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentPropertyArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ContentProperty"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentPropertyCreate

{
  "type": "object",
  "required": [
    "key",
    "value"
  ],
  "additionalProperties": false,
  "properties": {
    "key": {
      "type": "string",
      "description": "The key of the new property.",
      "maxLength": 255
    },
    "value": {
      "$ref": "#/components/schemas/PropertyValue"
    }
  },
  "title": "ContentPropertyCreate"
}

ContentPropertyCreateNoKey

{
  "type": "object",
  "required": [
    "value"
  ],
  "additionalProperties": false,
  "properties": {
    "value": {
      "$ref": "#/components/schemas/PropertyValue"
    }
  },
  "title": "ContentPropertyCreateNoKey"
}

ContentPropertyUpdate

{
  "type": "object",
  "required": [
    "value",
    "version"
  ],
  "additionalProperties": false,
  "properties": {
    "value": {
      "type": "object",
      "description": "The value of the property.",
      "minProperties": 1,
      "maxProperties": 1,
      "additionalProperties": {
        "type": "string"
      }
    },
    "version": {
      "type": "object",
      "description": "The version number of the property.",
      "required": [
        "number"
      ],
      "additionalProperties": false,
      "properties": {
        "number": {
          "type": "integer",
          "format": "int32",
          "description": "The new version for the updated content property. Set this to the\ncurrent version number incremented by one. To get the current\nversion number, use 'Get content property' and retrieve\n`version.number`."
        },
        "minorEdit": {
          "type": "boolean",
          "description": "If `minorEdit` is set to 'true', no notification email or activity\nstream will be generated for the change.",
          "default": true
        }
      }
    }
  },
  "title": "ContentPropertyUpdate"
}

ContentRestriction

{
  "type": "object",
  "required": [
    "operation",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "operation": {
      "type": "string",
      "enum": [
        "administer",
        "copy",
        "create",
        "delete",
        "export",
        "move",
        "purge",
        "purge_version",
        "read",
        "restore",
        "update",
        "use"
      ]
    },
    "restrictions": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "user": {
          "$ref": "#/components/schemas/UserArray"
        },
        "group": {
          "$ref": "#/components/schemas/GroupArray"
        },
        "_expandable": {
          "type": "object",
          "additionalProperties": false,
          "properties": {
            "user": {
              "type": "string"
            },
            "group": {
              "type": "string"
            }
          }
        }
      }
    },
    "content": {
      "$ref": "#/components/schemas/Content"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "restrictions": {
          "type": "string"
        },
        "content": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentRestrictionArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "restrictionsHash",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ContentRestriction"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "restrictionsHash": {
      "type": "string",
      "description": "This property is used by the UI to figure out whether a set of restrictions\nhas changed."
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentRestrictionUpdate

{
  "type": "object",
  "required": [
    "operation",
    "restrictions"
  ],
  "additionalProperties": false,
  "properties": {
    "operation": {
      "type": "string",
      "description": "The restriction operation applied to content.",
      "enum": [
        "administer",
        "copy",
        "create",
        "delete",
        "export",
        "move",
        "purge",
        "purge_version",
        "read",
        "restore",
        "update",
        "use"
      ]
    },
    "restrictions": {
      "type": "object",
      "description": "The users/groups that the restrictions will be applied to. At least one of\n`user` or `group` must be specified for this object.",
      "additionalProperties": false,
      "properties": {
        "user": {
          "type": "array",
          "description": "The users that the restrictions will be applied to. This array must\nhave at least one item, otherwise it should be omitted.",
          "items": {
            "type": "object",
            "description": "A user that the restriction will be applied to. Either the `username`\nor the `userKey` must be specified to identify the user.",
            "required": [
              "type"
            ],
            "additionalProperties": false,
            "properties": {
              "type": {
                "type": "string",
                "description": "Set to 'known'.",
                "enum": [
                  "known",
                  "unknown",
                  "anonymous",
                  "user"
                ]
              },
              "username": {
                "type": "string",
                "description": "This property has been deprecated due to privacy changes. Use `accountId` instead. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe username of the user. For example, _admin_. Required, unless `accountId` or `userKey` is specified."
              },
              "userKey": {
                "type": "string",
                "description": "This property has been deprecated due to privacy changes. Use `accountId` instead. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe user key of the user. Required, unless `accountId` or `username` is specified."
              },
              "accountId": {
                "type": "string",
                "description": "The account ID of the user, which uniquely identifies the user across all Atlassian products.\nFor example, `384093:32b4d9w0-f6a5-3535-11a3-9c8c88d10192`. Required, unless `username` or `userKey` is specified."
              }
            }
          }
        },
        "group": {
          "type": "array",
          "description": "The groups that the restrictions will be applied to. This array must\nhave at least one item, otherwise it should be omitted.",
          "items": {
            "type": "object",
            "description": "A group that the restriction will be applied to.",
            "required": [
              "type",
              "name"
            ],
            "additionalProperties": false,
            "properties": {
              "type": {
                "type": "string",
                "description": "Set to 'group'.",
                "enum": [
                  "group"
                ]
              },
              "name": {
                "type": "string",
                "description": "The name of the group."
              }
            }
          }
        }
      }
    }
  }
}

ContentRestrictionUpdateArray

{
  "type": "array",
  "items": {
    "$ref": "#/components/schemas/ContentRestrictionUpdate"
  },
  "title": "ContentRestrictionUpdateArray"
}

ContentTemplate

{
  "type": "object",
  "required": [
    "templateId",
    "name",
    "description",
    "labels",
    "templateType",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "templateId": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "labels": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Label"
      }
    },
    "templateType": {
      "type": "string"
    },
    "body": {
      "$ref": "#/components/schemas/ContentBody"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "body": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentTemplateArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ContentTemplate"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ContentTemplateCreate

{
  "type": "object",
  "description": "This object is used to create content templates.",
  "required": [
    "name",
    "templateType",
    "body"
  ],
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string",
      "description": "The name of the new template."
    },
    "templateType": {
      "type": "string",
      "description": "The type of the new template. Set to `page`."
    },
    "body": {
      "$ref": "#/components/schemas/ContentBodyCreate"
    },
    "description": {
      "type": "string",
      "description": "A description of the new template.",
      "maxLength": 255
    },
    "labels": {
      "type": "array",
      "description": "Labels for the new template.",
      "items": {
        "$ref": "#/components/schemas/Label"
      }
    },
    "space": {
      "type": "object",
      "description": "The key for the space of the new template. Only applies to space templates.\nIf the spaceKey is not specified, the template will be created as a global\ntemplate.",
      "required": [
        "key"
      ],
      "additionalProperties": false,
      "properties": {
        "key": {
          "type": "string"
        }
      }
    }
  },
  "title": "ContentTemplateCreate"
}

ContentTemplateUpdate

{
  "type": "object",
  "description": "This object is used to update content templates.",
  "required": [
    "templateId",
    "name",
    "templateType",
    "body"
  ],
  "additionalProperties": false,
  "properties": {
    "templateId": {
      "type": "string",
      "description": "The ID of the template being updated."
    },
    "name": {
      "type": "string",
      "description": "The name of the template. Set to the current `name` if this field is\nnot being updated."
    },
    "templateType": {
      "type": "string",
      "description": "The type of the template. Set to `page`.",
      "enum": [
        "page"
      ]
    },
    "body": {
      "$ref": "#/components/schemas/ContentBodyCreate"
    },
    "description": {
      "type": "string",
      "description": "A description of the template.",
      "maxLength": 100
    },
    "labels": {
      "type": "array",
      "description": "Labels for the template.",
      "items": {
        "$ref": "#/components/schemas/Label"
      }
    },
    "space": {
      "type": "object",
      "description": "The key for the space of the template. Required if the template is a\nspace template. Set this to the current `space.key`.",
      "required": [
        "key"
      ],
      "additionalProperties": false,
      "properties": {
        "key": {
          "type": "string"
        }
      }
    }
  },
  "title": "ContentTemplateUpdate"
}

ContentUpdate

{
  "type": "object",
  "required": [
    "version",
    "title",
    "type"
  ],
  "additionalProperties": false,
  "properties": {
    "version": {
      "type": "object",
      "required": [
        "number"
      ],
      "additionalProperties": false,
      "description": "The new version for the updated content. Set this to the current version number incremented by one, unless you are changing the status to 'draft' which must have a version number of 1.\n\nTo get the current version number, use [Get content by ID](#api-content-id-get) and retrieve `version.number`.",
      "properties": {
        "number": {
          "type": "integer",
          "format": "int32",
          "description": "The version number."
        }
      }
    },
    "title": {
      "type": "string",
      "description": "The updated title of the content. If you are not changing this field, set this to the current `title`.",
      "maxLength": 255
    },
    "type": {
      "type": "string",
      "description": "The type of content. Set this to the current type of the content.",
      "enum": [
        "page",
        "blogpost",
        "comment",
        "attachment"
      ]
    },
    "status": {
      "type": "string",
      "description": "The updated status of the content. Note, if you change the status of a page from\n'current' to 'draft' and it has an existing draft, the existing draft will be deleted\nin favor of the updated page.",
      "enum": [
        "current",
        "trashed",
        "historical",
        "draft"
      ]
    },
    "ancestors": {
      "type": "array",
      "description": "The new parent for the content. Only one parent content 'id' can be specified.",
      "items": {
        "type": "object",
        "required": [
          "id"
        ],
        "additionalProperties": false,
        "properties": {
          "id": {
            "type": "string",
            "description": "The `id` of the parent content."
          }
        }
      }
    },
    "body": {
      "type": "object",
      "description": "The updated body of the content. Does not apply to attachments.\nIf you are not sure how to generate these formats, you can create a page in the\nConfluence application, retrieve the content using [Get content](#api-content-get),\nand expand the desired content format, e.g. `expand=body.storage`.",
      "minProperties": 1,
      "maxProperties": 1,
      "additionalProperties": false,
      "properties": {
        "view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "export_view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "styled_view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "storage": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "editor2": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        },
        "anonymous_export_view": {
          "$ref": "#/components/schemas/ContentBodyCreate"
        }
      }
    }
  },
  "title": "ContentUpdate"
}

CopyPageHierarchy

{
  "type": "object",
  "properties": {
    "copyAttachments": {
      "type": "boolean"
    },
    "copyPermissions": {
      "type": "boolean"
    },
    "copyProperties": {
      "type": "boolean"
    },
    "copyLabels": {
      "type": "boolean"
    },
    "originalPageId": {
      "$ref": "#/components/schemas/ContentId"
    },
    "destinationPageId": {
      "$ref": "#/components/schemas/ContentId"
    },
    "titleOptions": {
      "$ref": "#/components/schemas/CopyPageHierarchyTitleOptions"
    }
  },
  "title": "CopyPageHierarchy"
}

CopyPageHierarchyTitleOptions

{
  "type": "object",
  "properties": {
    "prefix": {
      "type": "string"
    },
    "replace": {
      "type": "string"
    },
    "search": {
      "type": "string"
    }
  }
}

CQLPersonalDataConvertedQueries

{
  "type": "object",
  "required": [
    "queryStrings"
  ],
  "description": "The converted CQL queries.",
  "additionalProperties": false,
  "properties": {
    "queryStrings": {
      "type": "array",
      "description": "The list of converted CQL query strings with account IDs in\nplace of user identifiers.",
      "items": {
        "type": "string"
      }
    }
  }
}

CQLPersonalDataMigrationRequest

{
  "type": "object",
  "required": [
    "queryStrings"
  ],
  "description": "The CQL queries to be converted.",
  "additionalProperties": false,
  "properties": {
    "queryStrings": {
      "type": "array",
      "description": "A list of queries with user identifiers. Maximum of 100 queries.",
      "items": {
        "type": "string"
      },
      "example": [
        "type = page and creator != admin and space = DEV"
      ]
    }
  },
  "title": "CQLPersonalDataMigrationRequest"
}

Embeddable

{
  "type": "object"
}

EmbeddedContent

{
  "type": "object",
  "properties": {
    "entityId": {
      "type": "integer",
      "format": "int64"
    },
    "entity": {
      "$ref": "#/components/schemas/Embeddable"
    }
  }
}

GenericLinks

{
  "type": "object",
  "additionalProperties": {
    "type": "string"
  }
}

Group

{
  "type": "object",
  "required": [
    "type",
    "name",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "group"
      ],
      "default": "group"
    },
    "name": {
      "type": "string"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

GroupArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Group"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    }
  }
}

GroupArrayWithLinks

{
  "description": "Same as GroupArray but with `_links` property.",
  "allOf": [
    {
      "$ref": "#/components/schemas/GroupArray"
    },
    {
      "type": "object",
      "required": [
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    }
  ]
}

HeaderLookAndFeel

{
  "type": "object",
  "required": [
    "backgroundColor",
    "button",
    "primaryNavigation",
    "secondaryNavigation",
    "search"
  ],
  "additionalProperties": false,
  "properties": {
    "backgroundColor": {
      "type": "string"
    },
    "button": {
      "$ref": "#/components/schemas/ButtonLookAndFeel"
    },
    "primaryNavigation": {
      "$ref": "#/components/schemas/NavigationLookAndFeel"
    },
    "secondaryNavigation": {
      "$ref": "#/components/schemas/NavigationLookAndFeel"
    },
    "search": {
      "$ref": "#/components/schemas/SearchFieldLookAndFeel"
    }
  }
}

Icon

{
  "type": "object",
  "description": "This object represents an icon. If used as a profilePicture, this may be returned as null, depending on the user's privacy setting.",
  "required": [
    "path",
    "width",
    "height",
    "isDefault"
  ],
  "additionalProperties": false,
  "properties": {
    "path": {
      "type": "string"
    },
    "width": {
      "type": "integer",
      "format": "int32"
    },
    "height": {
      "type": "integer",
      "format": "int32"
    },
    "isDefault": {
      "type": "boolean"
    }
  }
}

Label

{
  "type": "object",
  "required": [
    "prefix",
    "name",
    "id",
    "label"
  ],
  "additionalProperties": false,
  "properties": {
    "prefix": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "id": {
      "type": "string"
    },
    "label": {
      "type": "string"
    }
  }
}

LabelArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Label"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

LabelCreate

{
  "type": "object",
  "required": [
    "prefix",
    "name"
  ],
  "additionalProperties": false,
  "properties": {
    "prefix": {
      "type": "string",
      "description": "The prefix for the label.",
      "enum": [
        "global",
        "my",
        "team"
      ]
    },
    "name": {
      "type": "string",
      "description": "The name of the label, which will be shown in the UI."
    }
  }
}

LabelCreateArray

{
  "type": "array",
  "items": {
    "$ref": "#/components/schemas/LabelCreate"
  },
  "title": "LabelCreateArray"
}

LookAndFeel

{
  "type": "object",
  "required": [
    "headings",
    "links",
    "menus",
    "header",
    "content",
    "bordersAndDividers"
  ],
  "additionalProperties": false,
  "properties": {
    "headings": {
      "type": "object",
      "required": [
        "color"
      ],
      "additionalProperties": false,
      "properties": {
        "color": {
          "type": "string"
        }
      }
    },
    "links": {
      "type": "object",
      "required": [
        "color"
      ],
      "additionalProperties": false,
      "properties": {
        "color": {
          "type": "string"
        }
      }
    },
    "menus": {
      "$ref": "#/components/schemas/MenusLookAndFeel"
    },
    "header": {
      "$ref": "#/components/schemas/HeaderLookAndFeel"
    },
    "content": {
      "$ref": "#/components/schemas/ContentLookAndFeel"
    },
    "bordersAndDividers": {
      "type": "object",
      "required": [
        "color"
      ],
      "additionalProperties": false,
      "properties": {
        "color": {
          "type": "string"
        }
      }
    }
  },
  "title": "LookAndFeel"
}

LookAndFeelUpdated

{
  "description": "Look and feel settings returned after an update.",
  "allOf": [
    {
      "$ref": "#/components/schemas/LookAndFeel"
    },
    {
      "type": "object",
      "required": [
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    }
  ]
}

LookAndFeelSettings

{
  "type": "object",
  "required": [
    "selected",
    "global",
    "custom"
  ],
  "additionalProperties": false,
  "properties": {
    "selected": {
      "type": "string",
      "enum": [
        "global",
        "custom"
      ]
    },
    "global": {
      "$ref": "#/components/schemas/LookAndFeel"
    },
    "theme": {
      "$ref": "#/components/schemas/LookAndFeel"
    },
    "custom": {
      "$ref": "#/components/schemas/LookAndFeel"
    }
  }
}

LookAndFeelType

{
  "type": "object",
  "description": "The object for choosing the look and feel settings for the site or a space.",
  "required": [
    "selected"
  ],
  "additionalProperties": false,
  "properties": {
    "selected": {
      "type": "string",
      "description": "The look and feel scheme. If you set this to `global`, you must specify\nthe current global look and feel settings as a `global` object in this\nrequest. Similarly, if you set this to `custom`, you must specify the\ncurrent custom look and feel settings as a `custom` object in this request.",
      "enum": [
        "global",
        "custom"
      ]
    },
    "global": {
      "$ref": "#/components/schemas/LookAndFeel"
    },
    "custom": {
      "$ref": "#/components/schemas/LookAndFeel"
    }
  },
  "title": "LookAndFeelType"
}

LongTaskStatus

{
  "type": "object",
  "required": [
    "id",
    "name",
    "elapsedTime",
    "percentageComplete",
    "successful",
    "messages"
  ],
  "additionalProperties": false,
  "properties": {
    "id": {
      "type": "string"
    },
    "name": {
      "type": "object",
      "required": [
        "key",
        "args"
      ],
      "additionalProperties": false,
      "properties": {
        "key": {
          "type": "string"
        },
        "args": {
          "type": "array",
          "items": {
            "type": "object"
          }
        }
      }
    },
    "elapsedTime": {
      "type": "integer",
      "format": "int64"
    },
    "percentageComplete": {
      "type": "integer",
      "format": "int32"
    },
    "successful": {
      "type": "boolean"
    },
    "messages": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Message"
      }
    }
  }
}

LongTaskStatusArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/LongTaskStatus"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

LongTaskStatusWithLinks

{
  "description": "Same as LongTaskStatus but with `_links` property.",
  "allOf": [
    {
      "$ref": "#/components/schemas/LongTaskStatus"
    },
    {
      "type": "object",
      "required": [
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    }
  ]
}

MacroInstance

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string"
    },
    "body": {
      "type": "string"
    },
    "parameters": {
      "type": "object",
      "additionalProperties": true
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

MenusLookAndFeel

{
  "type": "object",
  "required": [
    "hoverOrFocus",
    "color"
  ],
  "additionalProperties": false,
  "properties": {
    "hoverOrFocus": {
      "type": "object",
      "required": [
        "backgroundColor"
      ],
      "additionalProperties": false,
      "properties": {
        "backgroundColor": {
          "type": "string"
        }
      }
    },
    "color": {
      "type": "string"
    }
  }
}

Message

{
  "type": "object",
  "required": [
    "translation",
    "args"
  ],
  "additionalProperties": false,
  "properties": {
    "translation": {
      "type": "string"
    },
    "args": {
      "type": "array",
      "items": {
        "type": "object"
      }
    }
  }
}

MigratedUser

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "username": {
      "type": "string"
    },
    "key": {
      "type": "string"
    },
    "accountId": {
      "type": "string"
    }
  }
}

MigratedUserArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/MigratedUser"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

BulkUserLookup

{
  "type": "object",
  "required": [
    "type",
    "username",
    "userKey",
    "accountId",
    "accountType",
    "email",
    "publicName",
    "profilePicture",
    "displayName",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "known",
        "unknown",
        "anonymous",
        "user"
      ]
    },
    "username": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`, due to privacy changes. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe username of the user. For example, _admin_."
    },
    "userKey": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`, due to privacy changes. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe user key of the user."
    },
    "accountId": {
      "type": "string",
      "description": "The account ID of the user, which uniquely identifies the user across all Atlassian products.\nFor example, `384093:32b4d9w0-f6a5-3535-11a3-9c8c88d10192`."
    },
    "accountType": {
      "type": "string",
      "description": "The account type of the user, may return empty string if unavailable."
    },
    "email": {
      "type": "string",
      "description": "The email address of the user. Depending on the user's privacy setting, this may return an empty string."
    },
    "publicName": {
      "type": "string",
      "description": "The public name or nickname of the user. Will always contain a value."
    },
    "profilePicture": {
      "$ref": "#/components/schemas/Icon"
    },
    "displayName": {
      "type": "string",
      "description": "The display name of the user. Depending on the user's privacy setting, this may be the same as publicName."
    },
    "operations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/OperationCheckResult"
      }
    },
    "details": {
      "$ref": "#/components/schemas/UserDetails"
    },
    "personalSpace": {
      "$ref": "#/components/schemas/Space"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "operations": {
          "type": "string"
        },
        "details": {
          "type": "string"
        },
        "personalSpace": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

BulkUserLookupArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/BulkUserLookup"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

NavigationLookAndFeel

{
  "type": "object",
  "required": [
    "color",
    "hoverOrFocus"
  ],
  "properties": {
    "color": {
      "type": "string"
    },
    "hoverOrFocus": {
      "type": "object",
      "required": [
        "backgroundColor",
        "color"
      ],
      "additionalProperties": false,
      "properties": {
        "backgroundColor": {
          "type": "string"
        },
        "color": {
          "type": "string"
        }
      }
    }
  }
}

OperationCheckResult

{
  "type": "object",
  "description": "An operation and the target entity that it applies to, e.g. create page.",
  "required": [
    "operation",
    "targetType"
  ],
  "additionalProperties": false,
  "properties": {
    "operation": {
      "type": "string",
      "description": "The operation itself.",
      "enum": [
        "administer",
        "copy",
        "create",
        "delete",
        "export",
        "move",
        "purge",
        "purge_version",
        "read",
        "restore",
        "update",
        "use"
      ]
    },
    "targetType": {
      "type": "string",
      "description": "The space or content type that the operation applies to.",
      "enum": [
        "page",
        "blogpost",
        "comment",
        "attachment",
        "space"
      ]
    }
  }
}

PropertyValue

{
  "type": "object",
  "description": "The value of the property. This can be empty or a complex object.\nFor example,\n```\n\"value\": {\n  \"example1\": \"value\",\n  \"example2\": true,\n  \"example3\": 123\n}\n```",
  "additionalProperties": true
}

Relation

{
  "type": "object",
  "required": [
    "name",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string"
    },
    "relationData": {
      "$ref": "#/components/schemas/RelationData"
    },
    "source": {
      "type": "object",
      "additionalProperties": true
    },
    "target": {
      "type": "object",
      "additionalProperties": true
    },
    "_expandable": {
      "type": "object",
      "required": [
        "relationData",
        "source",
        "target"
      ],
      "additionalProperties": false,
      "properties": {
        "relationData": {
          "type": "string"
        },
        "source": {
          "type": "string"
        },
        "target": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

RelationArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Relation"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

RelationData

{
  "type": "object",
  "properties": {
    "createdBy": {
      "$ref": "#/components/schemas/User"
    },
    "createdDate": {
      "type": "string",
      "format": "date-time"
    },
    "friendlyCreatedDate": {
      "type": "string"
    }
  }
}

RetentionPeriod

{
  "type": "object",
  "required": [
    "number",
    "units"
  ],
  "additionalProperties": false,
  "properties": {
    "number": {
      "type": "integer",
      "description": "The number of units for the retention period.",
      "format": "int32"
    },
    "units": {
      "type": "string",
      "description": "The unit of time that the retention period is measured in.",
      "enum": [
        "NANOS",
        "MICROS",
        "MILLIS",
        "SECONDS",
        "MINUTES",
        "HOURS",
        "HALF_DAYS",
        "DAYS",
        "WEEKS",
        "MONTHS",
        "YEARS",
        "DECADES",
        "CENTURIES",
        "MILLENNIA",
        "ERAS",
        "FOREVER"
      ]
    }
  },
  "title": "RetentionPeriod"
}

ScreenLookAndFeel

{
  "type": "object",
  "required": [
    "background",
    "backgroundColor",
    "backgroundImage",
    "backgroundSize",
    "gutterTop",
    "gutterRight",
    "gutterBottom",
    "gutterLeft"
  ],
  "additionalProperties": false,
  "properties": {
    "background": {
      "type": "string"
    },
    "backgroundColor": {
      "type": "string"
    },
    "backgroundImage": {
      "type": "string"
    },
    "backgroundSize": {
      "type": "string"
    },
    "gutterTop": {
      "type": "string"
    },
    "gutterRight": {
      "type": "string"
    },
    "gutterBottom": {
      "type": "string"
    },
    "gutterLeft": {
      "type": "string"
    }
  }
}

SearchFieldLookAndFeel

{
  "type": "object",
  "required": [
    "backgroundColor",
    "color"
  ],
  "additionalProperties": false,
  "properties": {
    "backgroundColor": {
      "type": "string"
    },
    "color": {
      "type": "string"
    }
  }
}

SearchPageResponseSearchResult

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "totalSize",
    "cqlQuery",
    "searchDuration",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/SearchResult"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "totalSize": {
      "type": "integer",
      "format": "int32"
    },
    "cqlQuery": {
      "type": "string"
    },
    "searchDuration": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

SearchResult

{
  "type": "object",
  "required": [
    "content",
    "title",
    "excerpt",
    "url",
    "resultParentContainer",
    "resultGlobalContainer",
    "breadcrumbs",
    "entityType",
    "iconCssClass",
    "lastModified",
    "friendlyLastModified"
  ],
  "additionalProperties": false,
  "properties": {
    "content": {
      "$ref": "#/components/schemas/Content"
    },
    "title": {
      "type": "string"
    },
    "excerpt": {
      "type": "string"
    },
    "url": {
      "type": "string"
    },
    "resultParentContainer": {
      "$ref": "#/components/schemas/ContainerSummary"
    },
    "resultGlobalContainer": {
      "$ref": "#/components/schemas/ContainerSummary"
    },
    "breadcrumbs": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Breadcrumb"
      }
    },
    "entityType": {
      "type": "string"
    },
    "iconCssClass": {
      "type": "string"
    },
    "lastModified": {
      "type": "string",
      "format": "date-time"
    },
    "friendlyLastModified": {
      "type": "string"
    }
  }
}

Space

{
  "type": "object",
  "required": [
    "id",
    "key",
    "name",
    "type",
    "status",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "id": {
      "type": "integer",
      "format": "int64"
    },
    "key": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "icon": {
      "$ref": "#/components/schemas/Icon"
    },
    "description": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "plain": {
          "$ref": "#/components/schemas/SpaceDescription"
        },
        "view": {
          "$ref": "#/components/schemas/SpaceDescription"
        }
      }
    },
    "homepage": {
      "$ref": "#/components/schemas/Content"
    },
    "type": {
      "type": "string"
    },
    "metadata": {
      "type": "object",
      "required": [
        "labels"
      ],
      "additionalProperties": false,
      "properties": {
        "labels": {
          "$ref": "#/components/schemas/LabelArray"
        }
      }
    },
    "operations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/OperationCheckResult"
      }
    },
    "permissions": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/SpacePermission"
      }
    },
    "status": {
      "type": "string"
    },
    "settings": {
      "$ref": "#/components/schemas/SpaceSettings"
    },
    "theme": {
      "$ref": "#/components/schemas/Theme"
    },
    "lookAndFeel": {
      "$ref": "#/components/schemas/LookAndFeel"
    },
    "history": {
      "type": "object",
      "required": [
        "createdDate"
      ],
      "additionalProperties": false,
      "properties": {
        "createdDate": {
          "type": "string",
          "format": "date-time"
        }
      }
    },
    "_expandable": {
      "type": "object",
      "properties": {
        "settings": {
          "type": "string"
        },
        "metadata": {
          "type": "string"
        },
        "operations": {
          "type": "string"
        },
        "lookAndFeel": {
          "type": "string"
        },
        "permissions": {
          "type": "string"
        },
        "icon": {
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "theme": {
          "type": "string"
        },
        "history": {
          "type": "string"
        },
        "homepage": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

SpaceArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Space"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

SpaceCreate

{
  "type": "object",
  "description": "This is the request object used when creating a new space.",
  "required": [
    "key",
    "name"
  ],
  "additionalProperties": false,
  "properties": {
    "key": {
      "type": "string",
      "description": "The key for the new space. Format: See [Space\nkeys](https://confluence.atlassian.com/x/lqNMMQ)."
    },
    "name": {
      "type": "string",
      "description": "The name of the new space.",
      "maxLength": 200
    },
    "description": {
      "$ref": "#/components/schemas/SpaceDescriptionCreate"
    },
    "permissions": {
      "type": "array",
      "description": "The permissions for the new space. If no permissions are provided, the\n[Confluence default space permissions](https://confluence.atlassian.com/x/UAgzKw#CreateaSpace-Spacepermissions)\nare applied. Note, for security reasons, permissions cannot be changed\nvia the API after the space has been created, and must be changed via\nthe user interface instead.",
      "items": {
        "$ref": "#/components/schemas/SpacePermission"
      }
    }
  },
  "title": "SpaceCreate"
}

SpaceDescription

{
  "type": "object",
  "required": [
    "value",
    "representation",
    "embeddedContent"
  ],
  "additionalProperties": false,
  "properties": {
    "value": {
      "type": "string"
    },
    "representation": {
      "type": "string",
      "enum": [
        "plain",
        "view"
      ]
    },
    "embeddedContent": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": true
      }
    }
  }
}

SpaceDescriptionCreate

{
  "type": "object",
  "description": "The description of the new/updated space. Note, only the 'plain' representation\ncan be used for the description when creating or updating a space.",
  "required": [
    "plain"
  ],
  "additionalProperties": false,
  "properties": {
    "plain": {
      "type": "object",
      "properties": {
        "value": {
          "type": "string",
          "description": "The space description."
        },
        "representation": {
          "type": "string",
          "description": "Set to 'plain'."
        }
      }
    }
  }
}

SpacePermission

{
  "type": "object",
  "description": "This object represents the permissions for a space. Permissions consist of\nat least one operation object with an accompanying subjects object.\n\nThe following combinations of `operation` and `targetType` values are\nvalid for the `operation` object:\n\n  - 'create': 'page', 'blogpost', 'comment', 'attachment'\n  - 'read': 'space'\n  - 'delete': 'page', 'blogpost', 'comment', 'attachment'\n  - 'export': 'space'\n  - 'administer': 'space'",
  "required": [
    "subjects",
    "operation",
    "anonymousAccess",
    "unlicensedAccess"
  ],
  "additionalProperties": false,
  "properties": {
    "subjects": {
      "type": "object",
      "description": "The users and/or groups that the permission applies to.",
      "required": [
        "_expandable"
      ],
      "additionalProperties": false,
      "properties": {
        "user": {
          "type": "object",
          "required": [
            "results",
            "size"
          ],
          "additionalProperties": false,
          "properties": {
            "results": {
              "type": "array",
              "items": {
                "$ref": "#/components/schemas/User"
              }
            },
            "size": {
              "type": "integer",
              "format": "int32"
            }
          }
        },
        "group": {
          "type": "object",
          "required": [
            "results",
            "size"
          ],
          "additionalProperties": false,
          "properties": {
            "results": {
              "type": "array",
              "items": {
                "$ref": "#/components/schemas/Group"
              }
            },
            "size": {
              "type": "integer",
              "format": "int32"
            }
          }
        },
        "_expandable": {
          "type": "object",
          "properties": {
            "user": {
              "type": "string"
            },
            "group": {
              "type": "string"
            }
          }
        }
      }
    },
    "operation": {
      "$ref": "#/components/schemas/OperationCheckResult"
    },
    "anonymousAccess": {
      "type": "boolean",
      "description": "Grant anonymous users permission to use the operation.",
      "default": false
    },
    "unlicensedAccess": {
      "type": "boolean",
      "description": "Grants access to unlicensed users from JIRA Service Desk when used\nwith the 'read space' operation.",
      "default": false
    }
  }
}

SpacePrivateCreate

{
  "type": "object",
  "description": "This is the request object used when creating a new private space.",
  "required": [
    "key",
    "name"
  ],
  "additionalProperties": false,
  "properties": {
    "key": {
      "type": "string",
      "description": "The key for the new space. Format: See [Space\nkeys](https://confluence.atlassian.com/x/lqNMMQ)."
    },
    "name": {
      "type": "string",
      "description": "The name of the new space.",
      "maxLength": 200
    },
    "description": {
      "$ref": "#/components/schemas/SpaceDescriptionCreate"
    }
  },
  "title": "SpacePrivateCreate"
}

SpaceProperty

{
  "type": "object",
  "required": [
    "id",
    "key",
    "value",
    "_expandable"
  ],
  "additionalProperties": false,
  "properties": {
    "id": {
      "type": "integer",
      "format": "int64"
    },
    "key": {
      "type": "string"
    },
    "value": {
      "type": "object",
      "additionalProperties": true
    },
    "version": {
      "type": "object",
      "required": [
        "when",
        "message",
        "number",
        "minorEdit"
      ],
      "additionalProperties": false,
      "properties": {
        "when": {
          "type": "string",
          "format": "date-time"
        },
        "message": {
          "type": "string"
        },
        "number": {
          "type": "integer"
        },
        "minorEdit": {
          "type": "boolean"
        }
      }
    },
    "space": {
      "$ref": "#/components/schemas/Space"
    },
    "_expandable": {
      "type": "object",
      "properties": {
        "version": {
          "type": "string"
        },
        "space": {
          "type": "string"
        }
      }
    }
  }
}

SpacePropertyArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/SpaceProperty"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

SpacePropertyCreate

{
  "type": "object",
  "required": [
    "key",
    "value"
  ],
  "additionalProperties": false,
  "properties": {
    "key": {
      "type": "string",
      "description": "The key of the new property.",
      "maximum": 255
    },
    "value": {
      "$ref": "#/components/schemas/PropertyValue"
    }
  },
  "title": "SpacePropertyCreate"
}

SpacePropertyCreateNoKey

{
  "type": "object",
  "required": [
    "value"
  ],
  "additionalProperties": false,
  "properties": {
    "value": {
      "$ref": "#/components/schemas/PropertyValue"
    }
  },
  "title": "SpacePropertyCreateNoKey"
}

SpacePropertyUpdate

{
  "type": "object",
  "required": [
    "value",
    "version"
  ],
  "additionalProperties": false,
  "properties": {
    "value": {
      "type": "object",
      "description": "The value of the property.",
      "additionalProperties": true
    },
    "version": {
      "type": "object",
      "description": "The version number of the property.",
      "required": [
        "number"
      ],
      "additionalProperties": false,
      "properties": {
        "number": {
          "type": "integer",
          "format": "int32",
          "description": "The new version for the updated space property. Set this to the\ncurrent version number incremented by one. To get the current\nversion number, use 'Get space property' and retrieve\n`version.number`."
        },
        "minorEdit": {
          "type": "boolean",
          "description": "If `minorEdit` is set to 'true', no notification email or activity\nstream will be generated for the change.",
          "default": true
        }
      }
    }
  },
  "title": "SpacePropertyUpdate"
}

SpaceSettings

{
  "type": "object",
  "required": [
    "routeOverrideEnabled",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "routeOverrideEnabled": {
      "type": "boolean",
      "description": "Defines whether an override for the space home should be used. This is\nused in conjunction with a space theme provided by an app. For\nexample, if this property is set to true, a theme can display a page\nother than the space homepage when users visit the root URL for a\nspace. This property allows apps to provide content-only theming\nwithout overriding the space home."
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

SpaceSettingsUpdate

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "routeOverrideEnabled": {
      "type": "boolean",
      "description": "Defines whether an override for the space home should be used. This is\nused in conjunction with a space theme provided by an app. For\nexample, if this property is set to true, a theme can display a page\nother than the space homepage when users visit the root URL for a\nspace. This property allows apps to provide content-only theming\nwithout overriding the space home."
    }
  },
  "title": "SpaceSettingsUpdate"
}

SpaceUpdate

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string",
      "description": "The name of the space.",
      "maxLength": 200
    },
    "description": {
      "$ref": "#/components/schemas/SpaceDescriptionCreate"
    },
    "homepage": {
      "type": "object",
      "description": "The page to set as the homepage of the space.",
      "required": [
        "id"
      ],
      "additionalProperties": false,
      "properties": {
        "id": {
          "type": "string",
          "description": "The ID of the page."
        }
      }
    }
  },
  "title": "SpaceUpdate"
}

SpaceWatch

{
  "type": "object",
  "required": [
    "type",
    "watcher",
    "spaceKey"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string"
    },
    "watcher": {
      "$ref": "#/components/schemas/SpaceWatchUser"
    },
    "contentId": {
      "type": "string"
    },
    "spaceKey": {
      "type": "string"
    }
  }
}

SpaceWatchArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/SpaceWatch"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

SpaceWatchUser

{
  "type": "object",
  "description": "This essentially the same as the `User` object, but no `_links` property and\nno `_expandable` property (therefore, different required fields).",
  "required": [
    "type",
    "profilePicture",
    "displayName",
    "accountId",
    "accountType",
    "email",
    "publicName"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string"
    },
    "username": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe username of the user. For example, _admin_."
    },
    "userKey": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe user key of the user."
    },
    "accountId": {
      "type": "string",
      "description": "The account ID of the user, which uniquely identifies the user across all Atlassian products.\nFor example, `384093:32b4d9w0-f6a5-3535-11a3-9c8c88d10192`."
    },
    "profilePicture": {
      "$ref": "#/components/schemas/Icon"
    },
    "displayName": {
      "type": "string"
    },
    "operations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/OperationCheckResult"
      }
    },
    "details": {
      "$ref": "#/components/schemas/UserDetails"
    },
    "accountType": {
      "type": "string"
    },
    "email": {
      "type": "string"
    },
    "publicName": {
      "type": "string"
    }
  }
}

SuperBatchWebResources

{
  "type": "object",
  "properties": {
    "uris": {
      "type": "object",
      "properties": {
        "all": {
          "type": "string"
        },
        "css": {
          "type": "string"
        },
        "js": {
          "type": "string"
        }
      }
    },
    "tags": {
      "type": "object",
      "properties": {
        "all": {
          "type": "string"
        },
        "css": {
          "type": "string"
        },
        "data": {
          "type": "string"
        },
        "js": {
          "type": "string"
        }
      }
    },
    "metatags": {
      "type": "string"
    }
  }
}

SystemInfoEntity

{
  "type": "object",
  "required": [
    "cloudId",
    "commitHash"
  ],
  "additionalProperties": false,
  "properties": {
    "cloudId": {
      "type": "string"
    },
    "commitHash": {
      "type": "string"
    }
  }
}

Theme

{
  "allOf": [
    {
      "$ref": "#/components/schemas/ThemeNoLinks"
    },
    {
      "type": "object",
      "required": [
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    }
  ]
}

ThemeArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/ThemeNoLinks"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

ThemeNoLinks

{
  "type": "object",
  "description": "Theme object without links. Used in ThemeArray.",
  "required": [
    "themeKey",
    "name",
    "description",
    "icon"
  ],
  "additionalProperties": false,
  "properties": {
    "themeKey": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "icon": {
      "$ref": "#/components/schemas/Icon"
    }
  }
}

ThemeUpdate

{
  "type": "object",
  "required": [
    "themeKey"
  ],
  "additionalProperties": false,
  "properties": {
    "themeKey": {
      "type": "string",
      "description": "The key of the theme to be set as the space theme."
    }
  },
  "title": "ThemeUpdate"
}

User

{
  "type": "object",
  "required": [
    "type",
    "username",
    "userKey",
    "accountId",
    "accountType",
    "email",
    "publicName",
    "profilePicture",
    "displayName",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "known",
        "unknown",
        "anonymous",
        "user"
      ]
    },
    "username": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`, due to privacy changes. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe username of the user. For example, _admin_."
    },
    "userKey": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`, due to privacy changes. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe user key of the user."
    },
    "accountId": {
      "type": "string",
      "description": "The account ID of the user, which uniquely identifies the user across all Atlassian products.\nFor example, `384093:32b4d9w0-f6a5-3535-11a3-9c8c88d10192`."
    },
    "accountType": {
      "type": "string",
      "enum": [
        "atlassian",
        "app (if this user is a bot user created on behalf of an Atlassian app)"
      ],
      "description": "The account type of the user, may return empty string if unavailable."
    },
    "email": {
      "type": "string",
      "description": "The email address of the user. Depending on the user's privacy setting, this may return an empty string."
    },
    "publicName": {
      "type": "string",
      "description": "The public name or nickname of the user. Will always contain a value."
    },
    "profilePicture": {
      "$ref": "#/components/schemas/Icon"
    },
    "displayName": {
      "type": "string",
      "description": "The display name of the user. Depending on the user's privacy setting, this may be the same as publicName."
    },
    "operations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/OperationCheckResult"
      }
    },
    "details": {
      "$ref": "#/components/schemas/UserDetails"
    },
    "personalSpace": {
      "$ref": "#/components/schemas/Space"
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "operations": {
          "type": "string"
        },
        "details": {
          "type": "string"
        },
        "personalSpace": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

UserAnonymous

{
  "type": "object",
  "required": [
    "type",
    "profilePicture",
    "displayName",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string"
    },
    "profilePicture": {
      "$ref": "#/components/schemas/Icon"
    },
    "displayName": {
      "type": "string"
    },
    "operations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/OperationCheckResult"
      }
    },
    "_expandable": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "operations": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

UserArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size"
  ],
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/User"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    }
  }
}

UserArrayWithLinks

{
  "description": "Same as UserArray but with `_links` property.",
  "allOf": [
    {
      "$ref": "#/components/schemas/UserArray"
    },
    {
      "type": "object",
      "required": [
        "_links"
      ],
      "additionalProperties": false,
      "properties": {
        "_links": {
          "$ref": "#/components/schemas/GenericLinks"
        }
      }
    }
  ]
}

UserDetails

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "business": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "position": {
          "type": "string",
          "description": "This property has been deprecated due to privacy changes. There is no replacement. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details."
        },
        "department": {
          "type": "string",
          "description": "This property has been deprecated due to privacy changes. There is no replacement. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details."
        },
        "location": {
          "type": "string",
          "description": "This property has been deprecated due to privacy changes. There is no replacement. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details."
        }
      }
    },
    "personal": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "phone": {
          "type": "string",
          "description": "This property has been deprecated due to privacy changes. There is no replacement. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details."
        },
        "im": {
          "type": "string",
          "description": "This property has been deprecated due to privacy changes. There is no replacement. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details."
        },
        "website": {
          "type": "string",
          "description": "This property has been deprecated due to privacy changes. There is no replacement. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details."
        },
        "email": {
          "type": "string",
          "description": "This property has been deprecated due to privacy changes. Use the `User.email` property instead. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details."
        }
      }
    }
  }
}

UsersUserKeys

{
  "type": "object",
  "required": [
    "users",
    "userKeys"
  ],
  "additionalProperties": false,
  "properties": {
    "users": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/User"
      }
    },
    "userKeys": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

UserWatch

{
  "type": "object",
  "required": [
    "watching"
  ],
  "additionalProperties": false,
  "properties": {
    "watching": {
      "type": "boolean"
    }
  }
}

Version

{
  "type": "object",
  "required": [
    "by",
    "when",
    "friendlyWhen",
    "message",
    "number",
    "minorEdit",
    "_expandable",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "by": {
      "$ref": "#/components/schemas/User"
    },
    "when": {
      "type": "string",
      "format": "date-time"
    },
    "friendlyWhen": {
      "type": "string"
    },
    "message": {
      "type": "string"
    },
    "number": {
      "type": "integer",
      "format": "int32"
    },
    "minorEdit": {
      "type": "boolean"
    },
    "content": {
      "$ref": "#/components/schemas/Content"
    },
    "collaborators": {
      "$ref": "#/components/schemas/UsersUserKeys"
    },
    "_expandable": {
      "type": "object",
      "required": [
        "content",
        "collaborators"
      ],
      "properties": {
        "content": {
          "type": "string"
        },
        "collaborators": {
          "type": "string"
        }
      }
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

VersionArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Version"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

VersionRestore

{
  "type": "object",
  "required": [
    "operationKey",
    "params"
  ],
  "additionalProperties": false,
  "properties": {
    "operationKey": {
      "type": "string",
      "description": "Set to 'RESTORE'.",
      "enum": [
        "RESTORE"
      ]
    },
    "params": {
      "type": "object",
      "required": [
        "versionNumber",
        "message"
      ],
      "additionalProperties": false,
      "properties": {
        "versionNumber": {
          "type": "integer",
          "description": "The version number to be restored.",
          "format": "int32"
        },
        "message": {
          "type": "string",
          "description": "Description for the version."
        }
      }
    }
  },
  "title": "VersionRestore"
}

Watch

{
  "type": "object",
  "required": [
    "type",
    "watcher",
    "contentId"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string"
    },
    "watcher": {
      "$ref": "#/components/schemas/WatchUser"
    },
    "contentId": {
      "type": "string"
    }
  }
}

WatchArray

{
  "type": "object",
  "required": [
    "results",
    "start",
    "limit",
    "size",
    "_links"
  ],
  "additionalProperties": false,
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Watch"
      }
    },
    "start": {
      "type": "integer",
      "format": "int32"
    },
    "limit": {
      "type": "integer",
      "format": "int32"
    },
    "size": {
      "type": "integer",
      "format": "int32"
    },
    "_links": {
      "$ref": "#/components/schemas/GenericLinks"
    }
  }
}

WatchUser

{
  "type": "object",
  "description": "This essentially the same as the `User` object, but no `_links` property and\nno `_expandable` property (therefore, different required fields).",
  "required": [
    "type",
    "profilePicture",
    "username",
    "displayName",
    "userKey",
    "operations",
    "accountId",
    "details"
  ],
  "additionalProperties": false,
  "properties": {
    "type": {
      "type": "string"
    },
    "username": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe username of the user. For example, _admin_."
    },
    "userKey": {
      "type": "string",
      "description": "This property has been deprecated in favor of `accountId`. See the\n[migration guide](https://developer.atlassian.com/cloud/confluence/deprecation-notice-user-privacy-api-migration-guide/)\nfor details.\n\nThe user key of the user."
    },
    "accountId": {
      "type": "string",
      "description": "The account ID of the user, which uniquely identifies the user across all Atlassian products.\nFor example, `384093:32b4d9w0-f6a5-3535-11a3-9c8c88d10192`."
    },
    "profilePicture": {
      "$ref": "#/components/schemas/Icon"
    },
    "displayName": {
      "type": "string"
    },
    "operations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/OperationCheckResult"
      }
    },
    "details": {
      "$ref": "#/components/schemas/UserDetails"
    }
  }
}

WebResourceDependencies

{
  "type": "object",
  "properties": {
    "keys": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "contexts": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "uris": {
      "type": "object",
      "properties": {
        "all": {
          "type": "string"
        },
        "css": {
          "type": "string"
        },
        "js": {
          "type": "string"
        }
      }
    },
    "tags": {
      "type": "object",
      "properties": {
        "all": {
          "type": "string"
        },
        "css": {
          "type": "string"
        },
        "data": {
          "type": "string"
        },
        "js": {
          "type": "string"
        }
      }
    },
    "superbatch": {
      "$ref": "#/components/schemas/SuperBatchWebResources"
    }
  }
}