contentful-management.js - v7.39.1

Type declaration

• apiAdapter: Adapter

Type declaration

• accessToken: string

• Optional description?: undefined | string

• environments: { sys: MetaLinkProps }[]

• name: string

• Optional policies?: { action: string; effect: string }[]

• preview_api_key: { sys: MetaLinkProps }

  • sys: MetaLinkProps

• sys: MetaSysProps

Type declaration

• md5: string

• name: string

• size: number

Type declaration

• Optional comment?: undefined | string

  A comment that describes this bundle

• files: AppBundleFile[]

  List of all the files that are in this bundle

• sys: AppBundleSys

  System metadata

Type declaration

• Optional bundle?: Link<"AppBundle">

  Link to an AppBundle

• Optional locations?: AppLocation[]

  Locations where the app can be installed

• name: string

  App name

• Optional parameters?: undefined | { instance?: ParameterDefinition[] }

  Instance parameter definitions

• Optional src?: undefined | string

  URL where the root HTML document of the app can be found

• sys: BasicMetaSysProps & { organization: SysLink; shared: boolean }

  System metadata

Type declaration

• Optional parameters?: FreeFormParameters

  Free-form installation parameters (API limits stringified length to 16kB)

• sys: BasicMetaSysProps & { appDefinition: SysLink; environment: SysLink; space: SysLink }

Type declaration

• additionalHeaders: { x-contentful-environment-id: string; x-contentful-signature: string; x-contentful-signed-headers: string; x-contentful-space-id: string; x-contentful-timestamp: string; x-contentful-user-id: string }

  new headers to be included in the request

  • x-contentful-environment-id: string

  • x-contentful-signature: string

  • x-contentful-signed-headers: string

  • x-contentful-space-id: string

  • x-contentful-timestamp: string

  • x-contentful-user-id: string

• sys: AppSignedRequestSys

  System metadata

Type declaration

• redactedValue: string

  The last four characters of the signing secret

• sys: AppSigningSecretSys

  System metadata

Type declaration

• sys: AppUploadSys & { expiresAt: string; organization: SysLink }

Type declaration

• archive: function

  • archive(): Promise<Asset>

  • Archives the object

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getAsset('<asset_id>'))
    .then((asset) => asset.archive())
    .then((asset) => console.log(`Asset ${asset.sys.id} archived.`)
    .catch(console.error)
    

    Returns Promise<Asset>

    Object returned from the server with updated metadata.

• delete: function

  • delete(): Promise<void>

  • Deletes this object on the server.

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getAsset('<asset_id>'))
    .then((asset) => asset.delete())
    .then((asset) => console.log(`Asset deleted.`)
    .catch(console.error)
    

    Returns Promise<void>

    Promise for the deletion. It contains no data, but the Promise error case should be handled.

• isArchived: function

  • isArchived(): boolean

  • Checks if asset is archived. This means it's not exposed to the Delivery/Preview APIs.

    Returns boolean

• isDraft: function

  • isDraft(): boolean

  • Checks if the asset is in draft mode. This means it is not published.

    Returns boolean

• isPublished: function

  • isPublished(): boolean

  • Checks if the asset is published. A published asset might have unpublished changes

    Returns boolean

• isUpdated: function

  • isUpdated(): boolean

  • Checks if the asset is updated. This means the asset was previously published but has unpublished changes.

    Returns boolean

• processForAllLocales: function

  • processForAllLocales(options?: AssetProcessingForLocale): Promise<Asset>

  • Triggers asset processing after an upload, for the files uploaded to all locales of an asset.

    prop

    options.processingCheckWait - Time in milliseconds to wait before checking again if the asset has been processed (default: 500ms)

    prop

    options.processingCheckRetries - Maximum amount of times to check if the asset has been processed (default: 5)

    throws

    {AssetProcessingTimeout} If the asset takes too long to process. If this happens, retrieve the asset again, and if the url property is available, then processing has succeeded. If not, your file might be damaged.

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.createAssetWithId('<asset_id>', {
      title: {
        'en-US': 'Playsam Streamliner',
        'de-DE': 'Playsam Streamliner'
      },
      file: {
        'en-US': {
          contentType: 'image/jpeg',
          fileName: 'example.jpeg',
          upload: 'https://example.com/example.jpg'
        },
        'de-DE': {
          contentType: 'image/jpeg',
          fileName: 'example.jpeg',
          upload: 'https://example.com/example-de.jpg'
        }
      }
    }))
    .then((asset) => asset.processForAllLocales())
    .then((asset) => console.log(asset))
    .catch(console.error)
    

    Parameters

    • Optional options: AssetProcessingForLocale

      Additional options for processing

    Returns Promise<Asset>

    Object returned from the server with updated metadata.

• processForLocale: function

  • processForLocale(locale: string, Options?: AssetProcessingForLocale): Promise<Asset>

  • Triggers asset processing after an upload, for the file uploaded to a specific locale.

    prop

    options.processingCheckWait - Time in milliseconds to wait before checking again if the asset has been processed (default: 500ms)

    prop

    options.processingCheckRetries - Maximum amount of times to check if the asset has been processed (default: 5)

    throws

    {AssetProcessingTimeout} If the asset takes too long to process. If this happens, retrieve the asset again, and if the url property is available, then processing has succeeded. If not, your file might be damaged.

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.createAssetWithId('<asset_id>', {
      title: {
        'en-US': 'Playsam Streamliner',
      },
      file: {
        'en-US': {
          contentType: 'image/jpeg',
          fileName: 'example.jpeg',
          upload: 'https://example.com/example.jpg'
        }
      }
    }))
    .then((asset) => asset.processForLocale('en-US'))
    .then((asset) => console.log(asset))
    .catch(console.error)
    

    Parameters

    • locale: string

      Locale which processing should be triggered for

    • Optional Options: AssetProcessingForLocale

    Returns Promise<Asset>

    Object returned from the server with updated metadata.

• publish: function

  • publish(): Promise<Asset>

  • Publishes the object

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getAsset('<asset_id>'))
    .then((asset) => asset.publish())
    .then((asset) => console.log(`Asset ${asset.sys.id} published.`)
    .catch(console.error)
    

    Returns Promise<Asset>

    Object returned from the server with updated metadata.

• unarchive: function

  • unarchive(): Promise<Asset>

  • Unarchives the object

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getAsset('<asset_id>'))
    .then((asset) => asset.unarchive())
    .then((asset) => console.log(`Asset ${asset.sys.id} unarchived.`)
    .catch(console.error)
    

    Returns Promise<Asset>

    Object returned from the server with updated metadata.

• unpublish: function

  • unpublish(): Promise<Asset>

  • Unpublishes the object

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getAsset('<asset_id>'))
    .then((asset) => asset.unpublish())
    .then((asset) => console.log(`Asset ${asset.sys.id} unpublished.`)
    .catch(console.error)
    

    Returns Promise<Asset>

    Object returned from the server with updated metadata.

• update: function

  • update(): Promise<Asset>

  • Sends an update to the server with any changes made to the object's properties

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getAsset('<asset_id>'))
    .then((asset) => {
      asset.fields.title['en-US'] = 'New asset title'
      return asset.update()
    })
    .then((asset) => console.log(`Asset ${asset.sys.id} updated.`)
    .catch(console.error)
    

    Returns Promise<Asset>

    Object returned from the server with updated changes.

Type declaration

• policy: string

  A JWT describing a policy; needs to be attached to signed URLs

• secret: string

  A secret key to be used for signing URLs

Type declaration

• fields: { description?: undefined | {}; file: {}; title: {} }

  • Optional description?: undefined | {}

    Description for this asset

  • file: {}

    File object for this asset

    • [key: string]: { contentType: string; details?: Record<string, any>; fileName: string; upload?: undefined | string; uploadFrom?: Record<string, any>; url?: undefined | string }

      • contentType: string

      • Optional details?: Record<string, any>

        Details for the file, depending on file type (example: image size in bytes, etc)

      • fileName: string

      • Optional upload?: undefined | string

        Url where the file is available to be downloaded from, into the Contentful asset system. After the asset is processed this field is gone.

      • Optional uploadFrom?: Record<string, any>

      • Optional url?: undefined | string

        Url where the file is available at the Contentful media asset system. This field won't be available until the asset is processed.

  • title: {}

    Title for this asset

    • [key: string]: string

• Optional metadata?: MetadataProps

• sys: EntityMetaSysProps

Type declaration

• Optional initialDelayMs?: undefined | number

  Initial delay in milliseconds when performing the first check. This is used to prevent short running bulkActions of waiting too long for a result.

  default

  1000 (1s)

• Optional retryCount?: undefined | number

  The amount of times to retry.

  default

  30

• Optional retryIntervalMs?: undefined | number

  The interval between retries, in milliseconds (ms).

  default

  2000 (2s)

• Optional throwOnFailedExecution?: undefined | false | true

  Throws an error if the Action does not complete with a successful (succeeded) status.

  default

  true

Type declaration

• createdAt: ISO8601Timestamp

• createdBy: Link<"User">

• environment: Link<"Environment">

• id: string

• space: Link<"Space">

• status: BulkActionStatuses

• type: "BulkAction"

• updatedAt: ISO8601Timestamp

Type declaration

Type declaration

• delete: function

  • delete(): Promise<void>

  • Deletes this object on the server.

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getContentType('<contentType_id>'))
    .then((contentType) => contentType.delete())
    .then(() => console.log('contentType deleted'))
    .catch(console.error)
    

    Returns Promise<void>

    Promise for the deletion. It contains no data, but the Promise error case should be handled.

• getEditorInterface: function

  • getEditorInterface(): Promise<EditorInterface>

  • Gets the editor interface for the object
    Important note: The editor interface only represent a published contentType.
    To get the most recent representation of the contentType make sure to publish it first

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getContentType('<contentType_id>'))
    .then((contentType) => contentType.getEditorInterface())
    .then((editorInterface) => console.log(editorInterface.contorls))
    .catch(console.error)
    

    Returns Promise<EditorInterface>

    Object returned from the server with the current editor interface.

• getSnapshot: function

  • getSnapshot(snapshotId: string): Promise<SnapshotProps<ContentTypeProps>>

  • Gets a snapshot of a contentType

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getContentType('<contentType_id>'))
    .then((entry) => entry.getSnapshot('<snapshot-id>'))
    .then((snapshot) => console.log(snapshot))
    .catch(console.error)
    

    Parameters

    • snapshotId: string

      Id of the snapshot

    Returns Promise<SnapshotProps<ContentTypeProps>>

• getSnapshots: function

  • getSnapshots(): Promise<Collection<Snapshot<ContentTypeProps>, SnapshotProps<ContentTypeProps>>>

  • Gets all snapshots of a contentType

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getContentType('<contentType_id>'))
    .then((entry) => entry.getSnapshots())
    .then((snapshots) => console.log(snapshots.items))
    .catch(console.error)
    

    Returns Promise<Collection<Snapshot<ContentTypeProps>, SnapshotProps<ContentTypeProps>>>

• isDraft: function

  • isDraft(): boolean

  • Checks if the contentType is in draft mode. This means it is not published.

    Returns boolean

• isPublished: function

  • isPublished(): boolean

  • Checks if the contentType is published. A published contentType might have unpublished changes (@see {ContentType.isUpdated})

    Returns boolean

• isUpdated: function

  • isUpdated(): boolean

  • Checks if the contentType is updated. This means the contentType was previously published but has unpublished changes.

    Returns boolean

• omitAndDeleteField: function

  • omitAndDeleteField(id: string): Promise<ContentType>

  • Omits and deletes a field if it exists on the contentType. This is a convenience method which does both operations at once and potentially less safe than the standard way. See note about deleting fields on the Update method.

    Parameters

    • id: string

    Returns Promise<ContentType>

    Object returned from the server with updated metadata.

• publish: function

  • publish(): Promise<ContentType>

  • Publishes the object

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getContentType('<contentType_id>'))
    .then((contentType) => contentType.publish())
    .then((contentType) => console.log(`${contentType.sys.id} is published`))
    .catch(console.error)
    

    Returns Promise<ContentType>

    Object returned from the server with updated metadata.

• unpublish: function

  • unpublish(): Promise<ContentType>

  • Unpublishes the object

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getContentType('<contentType_id>'))
    .then((contentType) => contentType.unpublish())
    .then((contentType) => console.log(`${contentType.sys.id} is unpublished`))
    .catch(console.error)
    

    Returns Promise<ContentType>

    Object returned from the server with updated metadata.

• update: function

  • update(): Promise<ContentType>

  • Sends an update to the server with any changes made to the object's properties.
    Important note about deleting fields: The standard way to delete a field is with two updates: first omit the property from your responses (set the field attribute "omitted" to true), and then delete it by setting the attribute "deleted" to true. See the "Deleting fields" section in the API reference for more reasoning. Alternatively, you may use the convenience method omitAndDeleteField to do both steps at once.

    example

    const contentful = require('contentful-management')
    
    const client = contentful.createClient({
      accessToken: '<content_management_api_key>'
    })
    
    client.getSpace('<space_id>')
    .then((space) => space.getEnvironment('<environment_id>'))
    .then((environment) => environment.getContentType('<contentType_id>'))
    .then((contentType) => {
     contentType.name = 'New name'
     return contentType.update()
    })
    .then(contentType => console.log(contentType))
    .catch(console.error)
    

    Returns Promise<ContentType>

    Object returned from the server with updated changes.

Type declaration

• description: string

• displayField: string

  Field used as the main display field for Entries

• fields: ContentFields[]

  All the fields contained in this Content Type

• name: string

• sys: BasicMetaSysProps & { environment: SysLink; firstPublishedAt?: undefined | string; publishedCounter?: undefined | number; publishedVersion?: undefined | number; space: SysLink }

Type declaration

• appUploadId: string

• Optional comment?: undefined | string

Type declaration

• Optional body?: undefined | string

  optional stringified body of the request

• Optional headers?: Record<string, string>

  optional headers of the request

• method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH" | "HEAD"

  the request method

• path: string

  the path of the request method

Type declaration

• value: string

  A 64 character matching the regular expression /^[0-9a-zA-Z+/=_-]+$/

Type declaration

• expiresAt: number

  (required) UNIX timestamp in the future (but not more than 48 hours from now)

Type declaration

• extension: RequireExactlyOne<SetRequired<ExtensionProps["extension"], "name" | "fieldTypes" | "sidebar">, "src" | "srcdoc">

Type declaration

• Optional environmentId?: undefined | string

• Optional organizationId?: undefined | string

• Optional spaceId?: undefined | string

Type declaration

• Optional controls?: Control[]

  Array of fields and their associated widgetId

• Optional editor?: Editor

  Legacy singular editor override

• Optional editorLayout?: EditorLayoutItem[]

  Array of editor layout groups

• Optional editors?: Editor[]

  Array of editors. Defaults will be used if property is missing.

• Optional groupControls?: GroupControl[]

  Array of groups and their associated widgetId

• Optional sidebar?: SidebarItem[]

  Array of sidebar widgets. Defaults will be used if property is missing.

• sys: MetaSysProps & { contentType: { sys: MetaLinkProps }; environment: { sys: MetaLinkProps }; space: { sys: MetaLinkProps } }

Type declaration

• entity: VersionedLink<Entity> | Link<Entity>

• error: any

Type declaration

• Optional maxDepth?: undefined | number

Type declaration

• environment: { sys: MetaLinkProps }

  • sys: MetaLinkProps

• sys: BasicMetaSysProps & { space: SysLink }

  System meta data

Type declaration

• name: string

  Name of the environmant

• sys: EnvironmentMetaSys

  System metadata

Type declaration

• error: any

Type declaration

• extension: { fieldTypes: FieldType[]; name: string; parameters?: undefined | { installation?: ParameterDefinition[]; instance?: ParameterDefinition[] }; sidebar?: undefined | false | true; src?: undefined | string; srcdoc?: undefined | string }

  • fieldTypes: FieldType[]

    Field types where an extension can be used

  • name: string

    Extension name

  • Optional parameters?: undefined | { installation?: ParameterDefinition[]; instance?: ParameterDefinition[] }

    Parameter definitions

  • Optional sidebar?: undefined | false | true

    Controls the location of the extension. If true it will be rendered on the sidebar instead of replacing the field's editing control

  • Optional src?: undefined | string

    URL where the root HTML document of the extension can be found

  • Optional srcdoc?: undefined | string

    String representation of the extension (e.g. inline HTML code)

• Optional parameters?: DefinedParameters

  Values for installation parameters

• sys: ExtensionSysProps

Type declaration

• organizationId: string

Type declaration

• environmentId: string

• spaceId: string

Type declaration

• spaceId: string

Type declaration

• organizationId: string

• teamId: string

Type declaration

• code: string

  Locale code (example: en-us)

• contentDeliveryApi: boolean

  If the content under this locale should be available on the CDA (for public reading)

• contentManagementApi: boolean

  If the content under this locale should be available on the CMA (for editing)

• default: boolean

  If this is the default locale

• fallbackCode: string | null

  Locale code to fallback to when there is not content for the current locale

• internal_code: string

  Internal locale code

• name: string

  Locale name

• optional: boolean

  If the locale needs to be filled in on entries or not

• sys: BasicMetaSysProps & { environment: SysLink; space: SysLink }

Type declaration

• email: string

• firstName: string

• lastName: string

• role: string

• sys: MetaSysProps & { invitationUrl: string; organizationMembership: { sys: MetaLinkProps }; status: string; user: Record<string, any> | null }

Type declaration

• role: string

  Role

• status: boolean

  status

• sys: MetaSysProps & { user: { sys: MetaLinkProps } }

  System metadata

Type declaration

• name: string

  Name

• sys: MetaSysProps

  System metadata

Type declaration

• Optional query?: PaginationQueryOptions

Type declaration

• name: string

• revokedAt: null | string

• scopes: "content_management_manage"[]

• sys: MetaSysProps

• Optional token?: undefined | string

Type declaration

• apiKey: { create: any; createWithId: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams>, data: CreateApiKeyProps, headers?: Record<string, unknown>): Promise<ApiKeyProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • data: CreateApiKeyProps

      • Optional headers: Record<string, unknown>

      Returns Promise<ApiKeyProps>

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>, data: CreateApiKeyProps, headers?: Record<string, unknown>): Promise<ApiKeyProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>

      • data: CreateApiKeyProps

      • Optional headers: Record<string, unknown>

      Returns Promise<ApiKeyProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>): Promise<ApiKeyProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>

      Returns Promise<ApiKeyProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<ApiKeyProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<ApiKeyProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>, rawData: ApiKeyProps, headers?: Record<string, unknown>): Promise<ApiKeyProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { apiKeyId: string }>

      • rawData: ApiKeyProps

      • Optional headers: Record<string, unknown>

      Returns Promise<ApiKeyProps>

• appBundle: { create: any; delete: any; get: any; getMany: any }

  • create: function

    • create(params: OptionalDefaults<GetAppDefinitionParams>, payload: CreateAppBundleProps): Promise<AppBundleProps>

    • Parameters

      • params: OptionalDefaults<GetAppDefinitionParams>

      • payload: CreateAppBundleProps

      Returns Promise<AppBundleProps>

  • delete: function

    • delete(params: OptionalDefaults<GetAppBundleParams>): Promise<void>

    • Parameters

      • params: OptionalDefaults<GetAppBundleParams>

      Returns Promise<void>

  • get: function

    • get(params: OptionalDefaults<GetAppBundleParams>): Promise<AppBundleProps>

    • Parameters

      • params: OptionalDefaults<GetAppBundleParams>

      Returns Promise<AppBundleProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetAppDefinitionParams & QueryParams>): Promise<CollectionProp<AppBundleProps>>

    • Parameters

      • params: OptionalDefaults<GetAppDefinitionParams & QueryParams>

      Returns Promise<CollectionProp<AppBundleProps>>

• appDefinition: { create: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetOrganizationParams>, rawData: CreateAppDefinitionProps): Promise<AppDefinitionProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams>

      • rawData: CreateAppDefinitionProps

      Returns Promise<AppDefinitionProps>

  • delete: function

    • delete(params: OptionalDefaults<GetAppDefinitionParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetAppDefinitionParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetOrganizationParams & { appDefinitionId: string } & QueryParams>): Promise<AppDefinitionProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & { appDefinitionId: string } & QueryParams>

      Returns Promise<AppDefinitionProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<AppDefinitionProps>>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & QueryParams>

      Returns Promise<CollectionProp<AppDefinitionProps>>

  • update: function

    • update(params: OptionalDefaults<GetAppDefinitionParams>, rawData: AppDefinitionProps, headers?: Record<string, unknown>): Promise<AppDefinitionProps>

    • Parameters

      • params: OptionalDefaults<GetAppDefinitionParams>

      • rawData: AppDefinitionProps

      • Optional headers: Record<string, unknown>

      Returns Promise<AppDefinitionProps>

• appInstallation: { delete: any; get: any; getMany: any; upsert: any }

  • delete: function

    • delete(params: OptionalDefaults<GetAppInstallationParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetAppInstallationParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetAppInstallationParams>): Promise<AppInstallationProps>

    • Parameters

      • params: OptionalDefaults<GetAppInstallationParams>

      Returns Promise<AppInstallationProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & PaginationQueryParams>): Promise<CollectionProp<AppInstallationProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & PaginationQueryParams>

      Returns Promise<CollectionProp<AppInstallationProps>>

  • upsert: function

    • upsert(params: OptionalDefaults<GetAppInstallationParams>, rawData: CreateAppInstallationProps, headers?: Record<string, unknown>): Promise<AppInstallationProps>

    • Parameters

      • params: OptionalDefaults<GetAppInstallationParams>

      • rawData: CreateAppInstallationProps

      • Optional headers: Record<string, unknown>

      Returns Promise<AppInstallationProps>

• appSignedRequest: { create: any }

  • create: function

    • create(params: OptionalDefaults<GetAppInstallationParams>, payload: CreateAppSignedRequestProps): Promise<AppSignedRequestProps>

    • Parameters

      • params: OptionalDefaults<GetAppInstallationParams>

      • payload: CreateAppSignedRequestProps

      Returns Promise<AppSignedRequestProps>

• appSigningSecret: { delete: any; get: any; upsert: any }

  • delete: function

    • delete(params: OptionalDefaults<GetAppDefinitionParams>): Promise<void>

    • Parameters

      • params: OptionalDefaults<GetAppDefinitionParams>

      Returns Promise<void>

  • get: function

    • get(params: OptionalDefaults<GetAppDefinitionParams>): Promise<AppSigningSecretProps>

    • Parameters

      • params: OptionalDefaults<GetAppDefinitionParams>

      Returns Promise<AppSigningSecretProps>

  • upsert: function

    • upsert(params: OptionalDefaults<GetAppDefinitionParams>, payload: CreateAppSigningSecretProps): Promise<AppSigningSecretProps>

    • Parameters

      • params: OptionalDefaults<GetAppDefinitionParams>

      • payload: CreateAppSigningSecretProps

      Returns Promise<AppSigningSecretProps>

• appUpload: { create: any; delete: any; get: any }

  • create: function

    • create(params: OptionalDefaults<GetOrganizationParams>, payload: { file: string | ArrayBuffer | Stream }): Promise<AppUploadProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams>

      • payload: { file: string | ArrayBuffer | Stream }

        • file: string | ArrayBuffer | Stream

      Returns Promise<AppUploadProps>

  • delete: function

    • delete(params: OptionalDefaults<GetAppUploadParams>): Promise<void>

    • Parameters

      • params: OptionalDefaults<GetAppUploadParams>

      Returns Promise<void>

  • get: function

    • get(params: OptionalDefaults<GetAppUploadParams>): Promise<AppUploadProps>

    • Parameters

      • params: OptionalDefaults<GetAppUploadParams>

      Returns Promise<AppUploadProps>

• asset: { archive: any; create: any; createFromFiles: any; createWithId: any; delete: any; get: any; getMany: any; processForAllLocales: any; processForLocale: any; publish: any; unarchive: any; unpublish: any; update: any }

  • archive: function

    • archive(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>

      Returns Promise<AssetProps>

  • create: function

    • create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateAssetProps): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • rawData: CreateAssetProps

      Returns Promise<AssetProps>

  • createFromFiles: function

    • createFromFiles(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: Omit<AssetFileProp, "sys">): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • data: Omit<AssetFileProp, "sys">

      Returns Promise<AssetProps>

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>, rawData: CreateAssetProps): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>

      • rawData: CreateAssetProps

      Returns Promise<AssetProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string } & QueryParams>, rawData?: unknown, headers?: Record<string, unknown>): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string } & QueryParams>

      • Optional rawData: unknown

      • Optional headers: Record<string, unknown>

      Returns Promise<AssetProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<AssetProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>

      Returns Promise<CollectionProp<AssetProps>>

  • processForAllLocales: function

    • processForAllLocales(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • asset: AssetProps

      • Optional processingOptions: AssetProcessingForLocale

      Returns Promise<AssetProps>

  • processForLocale: function

    • processForLocale(params: OptionalDefaults<GetSpaceEnvironmentParams>, asset: AssetProps, locale: string, processingOptions?: AssetProcessingForLocale): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • asset: AssetProps

      • locale: string

      • Optional processingOptions: AssetProcessingForLocale

      Returns Promise<AssetProps>

  • publish: function

    • publish(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>, rawData: AssetProps): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>

      • rawData: AssetProps

      Returns Promise<AssetProps>

  • unarchive: function

    • unarchive(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>

      Returns Promise<AssetProps>

  • unpublish: function

    • unpublish(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>

      Returns Promise<AssetProps>

  • update: function

    • update(params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>, rawData: AssetProps, headers?: Record<string, unknown>): Promise<AssetProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { assetId: string }>

      • rawData: AssetProps

      • Optional headers: Record<string, unknown>

      Returns Promise<AssetProps>

• assetKey: { create: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateAssetKeyProps): Promise<AssetKeyProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • data: CreateAssetKeyProps

      Returns Promise<AssetKeyProps>

• bulkAction: { get: any; publish: any; unpublish: any; validate: any }

  • get: function

    • get<T>(params: GetBulkActionParams): Promise<BulkActionProps<T>>

    • Type parameters

      • T: BulkActionPayload = any

      Parameters

      • params: GetBulkActionParams

      Returns Promise<BulkActionProps<T>>

  • publish: function

    • publish(params: GetSpaceEnvironmentParams, payload: BulkActionPublishPayload): Promise<BulkActionProps<BulkActionPublishPayload>>

    • Parameters

      • params: GetSpaceEnvironmentParams

      • payload: BulkActionPublishPayload

      Returns Promise<BulkActionProps<BulkActionPublishPayload>>

  • unpublish: function

    • unpublish(params: GetSpaceEnvironmentParams, payload: BulkActionUnpublishPayload): Promise<BulkActionProps<BulkActionUnpublishPayload>>

    • Parameters

      • params: GetSpaceEnvironmentParams

      • payload: BulkActionUnpublishPayload

      Returns Promise<BulkActionProps<BulkActionUnpublishPayload>>

  • validate: function

    • validate(params: GetSpaceEnvironmentParams, payload: BulkActionValidatePayload): Promise<BulkActionProps<BulkActionValidatePayload>>

    • Parameters

      • params: GetSpaceEnvironmentParams

      • payload: BulkActionValidatePayload

      Returns Promise<BulkActionProps<BulkActionValidatePayload>>

• contentType: { create: any; createWithId: any; delete: any; get: any; getMany: any; omitAndDeleteField: any; publish: any; unpublish: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateContentTypeProps): Promise<ContentTypeProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • rawData: CreateContentTypeProps

      Returns Promise<ContentTypeProps>

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & { contentTypeId: string }>, rawData: CreateContentTypeProps): Promise<ContentTypeProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { contentTypeId: string }>

      • rawData: CreateContentTypeProps

      Returns Promise<ContentTypeProps>

  • delete: function

    • delete(params: OptionalDefaults<GetContentTypeParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetContentTypeParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetContentTypeParams & QueryParams>): Promise<ContentTypeProps>

    • Parameters

      • params: OptionalDefaults<GetContentTypeParams & QueryParams>

      Returns Promise<ContentTypeProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<ContentTypeProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>

      Returns Promise<CollectionProp<ContentTypeProps>>

  • omitAndDeleteField: function

    • omitAndDeleteField(params: OptionalDefaults<GetContentTypeParams>, contentType: ContentTypeProps, fieldId: string): Promise<ContentTypeProps>

    • Parameters

      • params: OptionalDefaults<GetContentTypeParams>

      • contentType: ContentTypeProps

      • fieldId: string

      Returns Promise<ContentTypeProps>

  • publish: function

    • publish(params: OptionalDefaults<GetContentTypeParams>, rawData: ContentTypeProps): Promise<ContentTypeProps>

    • Parameters

      • params: OptionalDefaults<GetContentTypeParams>

      • rawData: ContentTypeProps

      Returns Promise<ContentTypeProps>

  • unpublish: function

    • unpublish(params: OptionalDefaults<GetContentTypeParams>): Promise<ContentTypeProps>

    • Parameters

      • params: OptionalDefaults<GetContentTypeParams>

      Returns Promise<ContentTypeProps>

  • update: function

    • update(params: OptionalDefaults<GetContentTypeParams>, rawData: ContentTypeProps, headers?: Record<string, unknown>): Promise<ContentTypeProps>

    • Parameters

      • params: OptionalDefaults<GetContentTypeParams>

      • rawData: ContentTypeProps

      • Optional headers: Record<string, unknown>

      Returns Promise<ContentTypeProps>

• editorInterface: { get: any; getMany: any; update: any }

  • get: function

    • get(params: OptionalDefaults<GetEditorInterfaceParams>): Promise<EditorInterfaceProps>

    • Parameters

      • params: OptionalDefaults<GetEditorInterfaceParams>

      Returns Promise<EditorInterfaceProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<EditorInterfaceProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>

      Returns Promise<CollectionProp<EditorInterfaceProps>>

  • update: function

    • update(params: OptionalDefaults<GetEditorInterfaceParams>, rawData: EditorInterfaceProps, headers?: Record<string, unknown>): Promise<EditorInterfaceProps>

    • Parameters

      • params: OptionalDefaults<GetEditorInterfaceParams>

      • rawData: EditorInterfaceProps

      • Optional headers: Record<string, unknown>

      Returns Promise<EditorInterfaceProps>

• entry: { archive: any; create: any; createWithId: any; delete: any; get: any; getMany: any; patch: any; publish: any; references: any; unarchive: any; unpublish: any; update: any }

  • archive: function

    • archive<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      Returns Promise<EntryProps<T>>

  • create: function

    • create<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { contentTypeId: string }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { contentTypeId: string }>

      • rawData: CreateEntryProps<T>

      Returns Promise<EntryProps<T>>

  • createWithId: function

    • createWithId<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { contentTypeId: string; entryId: string }>, rawData: CreateEntryProps<T>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { contentTypeId: string; entryId: string }>

      • rawData: CreateEntryProps<T>

      Returns Promise<EntryProps<T>>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      Returns Promise<any>

  • get: function

    • get<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>, rawData?: unknown, headers?: Record<string, unknown>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      • Optional rawData: unknown

      • Optional headers: Record<string, unknown>

      Returns Promise<EntryProps<T>>

  • getMany: function

    • getMany<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<EntryProps<T>>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>

      Returns Promise<CollectionProp<EntryProps<T>>>

  • patch: function

    • patch<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>, rawData: OpPatch[], headers?: Record<string, unknown>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      • rawData: OpPatch[]

      • Optional headers: Record<string, unknown>

      Returns Promise<EntryProps<T>>

  • publish: function

    • publish<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>, rawData: EntryProps<T>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      • rawData: EntryProps<T>

      Returns Promise<EntryProps<T>>

  • references: function

    • references(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string; maxDepth?: undefined | number }>): Promise<EntryReferenceProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string; maxDepth?: undefined | number }>

      Returns Promise<EntryReferenceProps>

  • unarchive: function

    • unarchive<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      Returns Promise<EntryProps<T>>

  • unpublish: function

    • unpublish<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      Returns Promise<EntryProps<T>>

  • update: function

    • update<T>(params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>, rawData: EntryProps<T>, headers?: Record<string, unknown>): Promise<EntryProps<T>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { entryId: string }>

      • rawData: EntryProps<T>

      • Optional headers: Record<string, unknown>

      Returns Promise<EntryProps<T>>

• environment: { create: any; createWithId: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams>, rawData: Partial<Pick<EnvironmentProps, "name">>, headers?: Record<string, unknown>): Promise<EnvironmentProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • rawData: Partial<Pick<EnvironmentProps, "name">>

      • Optional headers: Record<string, unknown>

      Returns Promise<EnvironmentProps>

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetSpaceEnvironmentParams & { sourceEnvironmentId?: undefined | string }>, rawData: CreateEnvironmentProps, headers?: Record<string, unknown>): Promise<EnvironmentProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { sourceEnvironmentId?: undefined | string }>

      • rawData: CreateEnvironmentProps

      • Optional headers: Record<string, unknown>

      Returns Promise<EnvironmentProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceEnvironmentParams>): Promise<EnvironmentProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      Returns Promise<EnvironmentProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>): Promise<CollectionProp<EnvironmentProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>

      Returns Promise<CollectionProp<EnvironmentProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: EnvironmentProps, headers?: Record<string, unknown>): Promise<EnvironmentProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • rawData: EnvironmentProps

      • Optional headers: Record<string, unknown>

      Returns Promise<EnvironmentProps>

• environmentAlias: { createWithId: any; delete: any; get: any; getMany: any; update: any }

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetSpaceEnvAliasParams>, rawData: CreateEnvironmentAliasProps, headers?: Record<string, unknown>): Promise<EnvironmentAliasProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvAliasParams>

      • rawData: CreateEnvironmentAliasProps

      • Optional headers: Record<string, unknown>

      Returns Promise<EnvironmentAliasProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceEnvAliasParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvAliasParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceEnvAliasParams>): Promise<EnvironmentAliasProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvAliasParams>

      Returns Promise<EnvironmentAliasProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>): Promise<CollectionProp<EnvironmentAliasProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & PaginationQueryParams>

      Returns Promise<CollectionProp<EnvironmentAliasProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceEnvAliasParams>, rawData: EnvironmentAliasProps, headers?: Record<string, unknown>): Promise<EnvironmentAliasProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvAliasParams>

      • rawData: EnvironmentAliasProps

      • Optional headers: Record<string, unknown>

      Returns Promise<EnvironmentAliasProps>

• extension: { create: any; createWithId: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceEnvironmentParams>, rawData: CreateExtensionProps, headers?: Record<string, unknown>): Promise<ExtensionProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • rawData: CreateExtensionProps

      • Optional headers: Record<string, unknown>

      Returns Promise<ExtensionProps>

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetExtensionParams>, rawData: CreateExtensionProps, headers?: Record<string, unknown>): Promise<ExtensionProps>

    • Parameters

      • params: OptionalDefaults<GetExtensionParams>

      • rawData: CreateExtensionProps

      • Optional headers: Record<string, unknown>

      Returns Promise<ExtensionProps>

  • delete: function

    • delete(params: OptionalDefaults<GetExtensionParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetExtensionParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetExtensionParams & QueryParams>): Promise<ExtensionProps>

    • Parameters

      • params: OptionalDefaults<GetExtensionParams & QueryParams>

      Returns Promise<ExtensionProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<ExtensionProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>

      Returns Promise<CollectionProp<ExtensionProps>>

  • update: function

    • update(params: OptionalDefaults<GetExtensionParams>, rawData: ExtensionProps, headers?: Record<string, unknown>): Promise<ExtensionProps>

    • Parameters

      • params: OptionalDefaults<GetExtensionParams>

      • rawData: ExtensionProps

      • Optional headers: Record<string, unknown>

      Returns Promise<ExtensionProps>

• locale: { create: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: CreateLocaleProps, headers?: Record<string, unknown>): Promise<LocaleProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • data: CreateLocaleProps

      • Optional headers: Record<string, unknown>

      Returns Promise<LocaleProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceEnvironmentParams & { localeId: string }>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { localeId: string }>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceEnvironmentParams & { localeId: string }>): Promise<LocaleProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { localeId: string }>

      Returns Promise<LocaleProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<LocaleProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>

      Returns Promise<CollectionProp<LocaleProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceEnvironmentParams & { localeId: string }>, rawData: LocaleProps, headers?: Record<string, unknown>): Promise<LocaleProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { localeId: string }>

      • rawData: LocaleProps

      • Optional headers: Record<string, unknown>

      Returns Promise<LocaleProps>

• organization: { get: any; getAll: any }

  • get: function

    • get(params: OptionalDefaults<GetOrganizationParams>): Promise<OrganizationProp>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams>

      Returns Promise<OrganizationProp>

  • getAll: function

    • getAll(): Promise<CollectionProp<OrganizationProp>>

    • Returns Promise<CollectionProp<OrganizationProp>>

• organizationInvitation: { create: any; get: any }

  • create: function

    • create(params: OptionalDefaults<{ organizationId: string }>, data: CreateOrganizationInvitationProps, headers?: Record<string, unknown>): Promise<OrganizationInvitationProps>

    • Parameters

      • params: OptionalDefaults<{ organizationId: string }>

      • data: CreateOrganizationInvitationProps

      • Optional headers: Record<string, unknown>

      Returns Promise<OrganizationInvitationProps>

  • get: function

    • get(params: OptionalDefaults<{ invitationId: string; organizationId: string }>, headers?: Record<string, unknown>): Promise<OrganizationInvitationProps>

    • Parameters

      • params: OptionalDefaults<{ invitationId: string; organizationId: string }>

      • Optional headers: Record<string, unknown>

      Returns Promise<OrganizationInvitationProps>

• organizationMembership: { delete: any; get: any; getMany: any; update: any }

  • delete: function

    • delete(params: OptionalDefaults<GetOrganizationMembershipProps>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetOrganizationMembershipProps>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetOrganizationMembershipProps>): Promise<OrganizationMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationMembershipProps>

      Returns Promise<OrganizationMembershipProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<OrganizationMembershipProps>>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & QueryParams>

      Returns Promise<CollectionProp<OrganizationMembershipProps>>

  • update: function

    • update(params: OptionalDefaults<GetOrganizationMembershipProps>, rawData: OrganizationMembershipProps, headers?: Record<string, unknown>): Promise<OrganizationMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationMembershipProps>

      • rawData: OrganizationMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<OrganizationMembershipProps>

• personalAccessToken: { create: any; get: any; getMany: any; revoke: any }

  • create: function

    • create(rawData: CreatePersonalAccessTokenProps, headers?: Record<string, unknown>): Promise<PersonalAccessTokenProp>

    • Parameters

      • rawData: CreatePersonalAccessTokenProps

      • Optional headers: Record<string, unknown>

      Returns Promise<PersonalAccessTokenProp>

  • get: function

    • get(params: OptionalDefaults<{ tokenId: string }>): Promise<PersonalAccessTokenProp>

    • Parameters

      • params: OptionalDefaults<{ tokenId: string }>

      Returns Promise<PersonalAccessTokenProp>

  • getMany: function

    • getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<PersonalAccessTokenProp>>

    • Parameters

      • params: OptionalDefaults<QueryParams>

      Returns Promise<CollectionProp<PersonalAccessTokenProp>>

  • revoke: function

    • revoke(params: OptionalDefaults<{ tokenId: string }>): Promise<PersonalAccessTokenProp>

    • Parameters

      • params: OptionalDefaults<{ tokenId: string }>

      Returns Promise<PersonalAccessTokenProp>

• previewApiKey: { get: any; getMany: any }

  • get: function

    • get(params: OptionalDefaults<GetSpaceParams & { previewApiKeyId: string }>): Promise<PreviewApiKeyProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { previewApiKeyId: string }>

      Returns Promise<PreviewApiKeyProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<PreviewApiKeyProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<PreviewApiKeyProps>>

• raw: { delete: any; get: any; getDefaultParams: any; http: any; patch: any; post: any; put: any }

  • delete: function

    • delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>

    • Type parameters

      • T = unknown

      Parameters

      • url: string

      • Optional config: AxiosRequestConfig

      Returns Promise<T>

  • get: function

    • get<T>(url: string, config?: AxiosRequestConfig): Promise<T>

    • Type parameters

      • T = unknown

      Parameters

      • url: string

      • Optional config: AxiosRequestConfig

      Returns Promise<T>

  • getDefaultParams: function

    • getDefaultParams(): DefaultParams | undefined

    • Returns DefaultParams | undefined

  • http: function

    • http<T>(url: string, config?: AxiosRequestConfig): Promise<T>

    • Type parameters

      • T = unknown

      Parameters

      • url: string

      • Optional config: AxiosRequestConfig

      Returns Promise<T>

  • patch: function

    • patch<T>(url: string, payload?: any, config?: AxiosRequestConfig): Promise<T>

    • Type parameters

      • T = unknown

      Parameters

      • url: string

      • Optional payload: any

      • Optional config: AxiosRequestConfig

      Returns Promise<T>

  • post: function

    • post<T>(url: string, payload?: any, config?: AxiosRequestConfig): Promise<T>

    • Type parameters

      • T = unknown

      Parameters

      • url: string

      • Optional payload: any

      • Optional config: AxiosRequestConfig

      Returns Promise<T>

  • put: function

    • put<T>(url: string, payload?: any, config?: AxiosRequestConfig): Promise<T>

    • Type parameters

      • T = unknown

      Parameters

      • url: string

      • Optional payload: any

      • Optional config: AxiosRequestConfig

      Returns Promise<T>

• release: { create: any; delete: any; get: any; publish: any; query: any; unpublish: any; update: any; validate: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceEnvironmentParams>, data: ReleasePayload): Promise<ReleaseProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams>

      • data: ReleasePayload

      Returns Promise<ReleaseProps>

  • delete: function

    • delete(params: OptionalDefaults<GetReleaseParams>): Promise<void>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams>

      Returns Promise<void>

  • get: function

    • get(params: OptionalDefaults<GetReleaseParams>): Promise<ReleaseProps>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams>

      Returns Promise<ReleaseProps>

  • publish: function

    • publish(params: OptionalDefaults<GetReleaseParams & { version: number }>): Promise<ReleaseActionProps<"publish">>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams & { version: number }>

      Returns Promise<ReleaseActionProps<"publish">>

  • query: function

    • query(params: OptionalDefaults<GetSpaceEnvironmentParams> & { query?: ReleaseQueryOptions }): Promise<CollectionProp<ReleaseProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams> & { query?: ReleaseQueryOptions }

      Returns Promise<CollectionProp<ReleaseProps>>

  • unpublish: function

    • unpublish(params: OptionalDefaults<GetReleaseParams & { version: number }>): Promise<ReleaseActionProps<"unpublish">>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams & { version: number }>

      Returns Promise<ReleaseActionProps<"unpublish">>

  • update: function

    • update(params: OptionalDefaults<GetReleaseParams & { version: number }>, data: ReleasePayload): Promise<ReleaseProps>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams & { version: number }>

      • data: ReleasePayload

      Returns Promise<ReleaseProps>

  • validate: function

    • validate(params: OptionalDefaults<GetReleaseParams>, data?: ReleaseValidatePayload): Promise<ReleaseActionProps<"validate">>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams>

      • Optional data: ReleaseValidatePayload

      Returns Promise<ReleaseActionProps<"validate">>

• releaseAction: { get: any; queryForRelease: any }

  • get: function

    • get(params: OptionalDefaults<GetReleaseParams> & { actionId: string }): Promise<ReleaseActionProps>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams> & { actionId: string }

      Returns Promise<ReleaseActionProps>

  • queryForRelease: function

    • queryForRelease(params: OptionalDefaults<GetReleaseParams> & { query?: ReleaseActionQueryOptions }): Promise<CollectionProp<ReleaseActionProps>>

    • Parameters

      • params: OptionalDefaults<GetReleaseParams> & { query?: ReleaseActionQueryOptions }

      Returns Promise<CollectionProp<ReleaseActionProps>>

• role: { create: any; createWithId: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams>, data: CreateRoleProps, headers?: Record<string, unknown>): Promise<RoleProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • data: CreateRoleProps

      • Optional headers: Record<string, unknown>

      Returns Promise<RoleProps>

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetSpaceParams & { roleId: string }>, data: CreateRoleProps, headers?: Record<string, unknown>): Promise<RoleProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { roleId: string }>

      • data: CreateRoleProps

      • Optional headers: Record<string, unknown>

      Returns Promise<RoleProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceParams & { roleId: string }>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { roleId: string }>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceParams & { roleId: string }>): Promise<RoleProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { roleId: string }>

      Returns Promise<RoleProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<RoleProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<RoleProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceParams & { roleId: string }>, rawData: RoleProps, headers?: Record<string, unknown>): Promise<RoleProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { roleId: string }>

      • rawData: RoleProps

      • Optional headers: Record<string, unknown>

      Returns Promise<RoleProps>

• scheduledActions: { create: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams>, data: CreateUpdateScheduledActionProps): Promise<ScheduledActionProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • data: CreateUpdateScheduledActionProps

      Returns Promise<ScheduledActionProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceEnvironmentParams & { scheduledActionId: string }>): Promise<ScheduledActionProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & { scheduledActionId: string }>

      Returns Promise<ScheduledActionProps>

  • get: function

    • get(params: OptionalDefaults<GetSpaceParams> & { environmentId: string; scheduledActionId: string }): Promise<ScheduledActionProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams> & { environmentId: string; scheduledActionId: string }

      Returns Promise<ScheduledActionProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CursorPaginatedCollectionProp<ScheduledActionProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CursorPaginatedCollectionProp<ScheduledActionProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceParams & { scheduledActionId: string; version: number }>, data: CreateUpdateScheduledActionProps): Promise<ScheduledActionProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { scheduledActionId: string; version: number }>

      • data: CreateUpdateScheduledActionProps

      Returns Promise<ScheduledActionProps>

• snapshot: { getForContentType: any; getForEntry: any; getManyForContentType: any; getManyForEntry: any }

  • getForContentType: function

    • getForContentType(params: OptionalDefaults<GetSnapshotForContentTypeParams & { snapshotId: string }>): Promise<SnapshotProps<ContentTypeProps>>

    • Parameters

      • params: OptionalDefaults<GetSnapshotForContentTypeParams & { snapshotId: string }>

      Returns Promise<SnapshotProps<ContentTypeProps>>

  • getForEntry: function

    • getForEntry<T>(params: OptionalDefaults<GetSnapshotForEntryParams & { snapshotId: string }>): Promise<SnapshotProps<EntryProps<T>>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSnapshotForEntryParams & { snapshotId: string }>

      Returns Promise<SnapshotProps<EntryProps<T>>>

  • getManyForContentType: function

    • getManyForContentType(params: OptionalDefaults<GetSnapshotForContentTypeParams & QueryParams>): Promise<CollectionProp<SnapshotProps<ContentTypeProps>>>

    • Parameters

      • params: OptionalDefaults<GetSnapshotForContentTypeParams & QueryParams>

      Returns Promise<CollectionProp<SnapshotProps<ContentTypeProps>>>

  • getManyForEntry: function

    • getManyForEntry<T>(params: OptionalDefaults<GetSnapshotForEntryParams & QueryParams>): Promise<CollectionProp<SnapshotProps<EntryProps<T>>>>

    • Type parameters

      • T: KeyValueMap = KeyValueMap

      Parameters

      • params: OptionalDefaults<GetSnapshotForEntryParams & QueryParams>

      Returns Promise<CollectionProp<SnapshotProps<EntryProps<T>>>>

• space: { create: any; delete: any; get: any; getMany: any; update: any }

  • create: function

    • create(params: OptionalDefaults<{ organizationId?: undefined | string }>, payload: Omit<SpaceProps, "sys">, headers?: Record<string, unknown>): Promise<any>

    • Parameters

      • params: OptionalDefaults<{ organizationId?: undefined | string }>

      • payload: Omit<SpaceProps, "sys">

      • Optional headers: Record<string, unknown>

      Returns Promise<any>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceParams>): Promise<SpaceProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      Returns Promise<SpaceProps>

  • getMany: function

    • getMany(params: OptionalDefaults<QueryParams>): Promise<CollectionProp<SpaceProps>>

    • Parameters

      • params: OptionalDefaults<QueryParams>

      Returns Promise<CollectionProp<SpaceProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceParams>, payload: SpaceProps, headers?: Record<string, unknown>): Promise<SpaceProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • payload: SpaceProps

      • Optional headers: Record<string, unknown>

      Returns Promise<SpaceProps>

• spaceMember: { get: any; getMany: any }

  • get: function

    • get(params: OptionalDefaults<GetSpaceParams & { spaceMemberId: string }>): Promise<SpaceMemberProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { spaceMemberId: string }>

      Returns Promise<SpaceMemberProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<SpaceMemberProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<SpaceMemberProps>>

• spaceMembership: { create: any; createWithId: any; delete: any; get: any; getForOrganization: any; getMany: any; getManyForOrganization: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams>, data: CreateSpaceMembershipProps, headers?: Record<string, unknown>): Promise<SpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • data: CreateSpaceMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<SpaceMembershipProps>

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetSpaceMembershipProps>, data: CreateSpaceMembershipProps, headers?: Record<string, unknown>): Promise<SpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceMembershipProps>

      • data: CreateSpaceMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<SpaceMembershipProps>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceMembershipProps>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceMembershipProps>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceMembershipProps>): Promise<SpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceMembershipProps>

      Returns Promise<SpaceMembershipProps>

  • getForOrganization: function

    • getForOrganization(params: OptionalDefaults<GetOrganizationParams & { spaceMembershipId: string }>): Promise<SpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & { spaceMembershipId: string }>

      Returns Promise<SpaceMembershipProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<SpaceMembershipProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<SpaceMembershipProps>>

  • getManyForOrganization: function

    • getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<SpaceMembershipProps>>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & QueryParams>

      Returns Promise<CollectionProp<SpaceMembershipProps>>

  • update: function

    • update(params: OptionalDefaults<GetSpaceMembershipProps>, rawData: SpaceMembershipProps, headers?: Record<string, unknown>): Promise<SpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceMembershipProps>

      • rawData: SpaceMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<SpaceMembershipProps>

• tag: { createWithId: any; delete: any; get: any; getMany: any; update: any }

  • createWithId: function

    • createWithId(params: OptionalDefaults<GetTagParams>, rawData: CreateTagProps): Promise<TagProps>

    • Parameters

      • params: OptionalDefaults<GetTagParams>

      • rawData: CreateTagProps

      Returns Promise<TagProps>

  • delete: function

    • delete(params: OptionalDefaults<GetTagParams>, version: number): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetTagParams>

      • version: number

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetTagParams>): Promise<TagProps>

    • Parameters

      • params: OptionalDefaults<GetTagParams>

      Returns Promise<TagProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>): Promise<CollectionProp<TagProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceEnvironmentParams & QueryParams>

      Returns Promise<CollectionProp<TagProps>>

  • update: function

    • update(params: OptionalDefaults<GetTagParams>, rawData: UpdateTagProps, headers?: Record<string, unknown>): Promise<TagProps>

    • Parameters

      • params: OptionalDefaults<GetTagParams>

      • rawData: UpdateTagProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TagProps>

• task: { create: any; delete: any; get: any; getAll: any; update: any }

  • create: function

    • create(params: OptionalDefaults<CreateTaskParams>, rawData: CreateTaskProps, headers?: Record<string, unknown>): Promise<TaskProps>

    • Parameters

      • params: OptionalDefaults<CreateTaskParams>

      • rawData: CreateTaskProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TaskProps>

  • delete: function

    • delete(params: OptionalDefaults<DeleteTaskParams>): Promise<void>

    • Parameters

      • params: OptionalDefaults<DeleteTaskParams>

      Returns Promise<void>

  • get: function

    • get(params: OptionalDefaults<GetTaskParams>): Promise<TaskProps>

    • Parameters

      • params: OptionalDefaults<GetTaskParams>

      Returns Promise<TaskProps>

  • getAll: function

    • getAll(params: OptionalDefaults<GetEntryParams>): Promise<CollectionProp<TaskProps>>

    • Parameters

      • params: OptionalDefaults<GetEntryParams>

      Returns Promise<CollectionProp<TaskProps>>

  • update: function

    • update(params: OptionalDefaults<UpdateTaskParams>, rawData: UpdateTaskProps, headers?: Record<string, unknown>): Promise<TaskProps>

    • Parameters

      • params: OptionalDefaults<UpdateTaskParams>

      • rawData: UpdateTaskProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TaskProps>

• team: { create: any; delete: any; get: any; getMany: any; getManyForSpace: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetOrganizationParams>, rawData: CreateTeamProps, headers?: Record<string, unknown>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams>

      • rawData: CreateTeamProps

      • Optional headers: Record<string, unknown>

      Returns Promise<any>

  • delete: function

    • delete(params: OptionalDefaults<GetTeamParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetTeamParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetTeamParams>): Promise<TeamProps>

    • Parameters

      • params: OptionalDefaults<GetTeamParams>

      Returns Promise<TeamProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<TeamProps>>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & QueryParams>

      Returns Promise<CollectionProp<TeamProps>>

  • getManyForSpace: function

    • getManyForSpace(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<TeamProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<TeamProps>>

  • update: function

    • update(params: OptionalDefaults<GetTeamParams>, rawData: TeamProps, headers?: Record<string, unknown>): Promise<TeamProps>

    • Parameters

      • params: OptionalDefaults<GetTeamParams>

      • rawData: TeamProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TeamProps>

• teamMembership: { create: any; delete: any; get: any; getManyForOrganization: any; getManyForTeam: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetTeamParams>, rawData: CreateTeamMembershipProps, headers?: Record<string, unknown>): Promise<TeamMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetTeamParams>

      • rawData: CreateTeamMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TeamMembershipProps>

  • delete: function

    • delete(params: OptionalDefaults<GetTeamMembershipParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetTeamMembershipParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetTeamMembershipParams>): Promise<TeamMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetTeamMembershipParams>

      Returns Promise<TeamMembershipProps>

  • getManyForOrganization: function

    • getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<TeamMembershipProps>>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & QueryParams>

      Returns Promise<CollectionProp<TeamMembershipProps>>

  • getManyForTeam: function

    • getManyForTeam(params: OptionalDefaults<GetTeamParams & QueryParams>): Promise<CollectionProp<TeamMembershipProps>>

    • Parameters

      • params: OptionalDefaults<GetTeamParams & QueryParams>

      Returns Promise<CollectionProp<TeamMembershipProps>>

  • update: function

    • update(params: OptionalDefaults<GetTeamMembershipParams>, rawData: TeamMembershipProps, headers?: Record<string, unknown>): Promise<TeamMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetTeamMembershipParams>

      • rawData: TeamMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TeamMembershipProps>

• teamSpaceMembership: { create: any; delete: any; get: any; getForOrganization: any; getMany: any; getManyForOrganization: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams & { teamId: string }>, rawData: CreateTeamSpaceMembershipProps, headers?: Record<string, unknown>): Promise<TeamSpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { teamId: string }>

      • rawData: CreateTeamSpaceMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TeamSpaceMembershipProps>

  • delete: function

    • delete(params: OptionalDefaults<GetTeamSpaceMembershipParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetTeamSpaceMembershipParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetTeamSpaceMembershipParams>): Promise<TeamSpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetTeamSpaceMembershipParams>

      Returns Promise<TeamSpaceMembershipProps>

  • getForOrganization: function

    • getForOrganization(params: OptionalDefaults<GetOrganizationParams & { teamSpaceMembershipId: string }>): Promise<TeamSpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & { teamSpaceMembershipId: string }>

      Returns Promise<TeamSpaceMembershipProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<TeamSpaceMembershipProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<TeamSpaceMembershipProps>>

  • getManyForOrganization: function

    • getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams & { teamId?: undefined | string }>): Promise<CollectionProp<TeamSpaceMembershipProps>>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & QueryParams & { teamId?: undefined | string }>

      Returns Promise<CollectionProp<TeamSpaceMembershipProps>>

  • update: function

    • update(params: OptionalDefaults<GetTeamSpaceMembershipParams>, rawData: TeamSpaceMembershipProps, headers?: Record<string, unknown>): Promise<TeamSpaceMembershipProps>

    • Parameters

      • params: OptionalDefaults<GetTeamSpaceMembershipParams>

      • rawData: TeamSpaceMembershipProps

      • Optional headers: Record<string, unknown>

      Returns Promise<TeamSpaceMembershipProps>

• upload: { create: any; delete: any; get: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams>, data: { file: string | ArrayBuffer | Stream }): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • data: { file: string | ArrayBuffer | Stream }

        • file: string | ArrayBuffer | Stream

      Returns Promise<any>

  • delete: function

    • delete(params: OptionalDefaults<GetSpaceParams & { uploadId: string }>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { uploadId: string }>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetSpaceParams & { uploadId: string }>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { uploadId: string }>

      Returns Promise<any>

• usage: { getManyForOrganization: any; getManyForSpace: any }

  • getManyForOrganization: function

    • getManyForOrganization(params: OptionalDefaults<{ organizationId: string } & QueryParams>): Promise<CollectionProp<UsageProps>>

    • Parameters

      • params: OptionalDefaults<{ organizationId: string } & QueryParams>

      Returns Promise<CollectionProp<UsageProps>>

  • getManyForSpace: function

    • getManyForSpace(params: OptionalDefaults<{ organizationId: string } & QueryParams>): Promise<CollectionProp<UsageProps>>

    • Parameters

      • params: OptionalDefaults<{ organizationId: string } & QueryParams>

      Returns Promise<CollectionProp<UsageProps>>

• user: { getCurrent: any; getForOrganization: any; getForSpace: any; getManyForOrganization: any; getManyForSpace: any }

  • getCurrent: function

    • getCurrent<T>(params?: QueryParams): Promise<T>

    • Type parameters

      • T = UserProps

      Parameters

      • Optional params: QueryParams

      Returns Promise<T>

  • getForOrganization: function

    • getForOrganization(params: OptionalDefaults<GetOrganizationParams & { userId: string }>): Promise<UserProps>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & { userId: string }>

      Returns Promise<UserProps>

  • getForSpace: function

    • getForSpace(params: OptionalDefaults<GetSpaceParams & { userId: string }>): Promise<UserProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & { userId: string }>

      Returns Promise<UserProps>

  • getManyForOrganization: function

    • getManyForOrganization(params: OptionalDefaults<GetOrganizationParams & QueryParams>): Promise<CollectionProp<UserProps>>

    • Parameters

      • params: OptionalDefaults<GetOrganizationParams & QueryParams>

      Returns Promise<CollectionProp<UserProps>>

  • getManyForSpace: function

    • getManyForSpace(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<UserProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<UserProps>>

• webhook: { create: any; delete: any; get: any; getCallDetails: any; getHealthStatus: any; getMany: any; getManyCallDetails: any; update: any }

  • create: function

    • create(params: OptionalDefaults<GetSpaceParams>, rawData: CreateWebhooksProps, headers?: Record<string, unknown>): Promise<WebhookProps>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams>

      • rawData: CreateWebhooksProps

      • Optional headers: Record<string, unknown>

      Returns Promise<WebhookProps>

  • delete: function

    • delete(params: OptionalDefaults<GetWebhookParams>): Promise<any>

    • Parameters

      • params: OptionalDefaults<GetWebhookParams>

      Returns Promise<any>

  • get: function

    • get(params: OptionalDefaults<GetWebhookParams>): Promise<WebhookProps>

    • Parameters

      • params: OptionalDefaults<GetWebhookParams>

      Returns Promise<WebhookProps>

  • getCallDetails: function

    • getCallDetails(params: OptionalDefaults<GetWebhookCallDetailsUrl>): Promise<WebhookCallDetailsProps>

    • Parameters

      • params: OptionalDefaults<GetWebhookCallDetailsUrl>

      Returns Promise<WebhookCallDetailsProps>

  • getHealthStatus: function

    • getHealthStatus(params: OptionalDefaults<GetWebhookParams>): Promise<WebhookHealthProps>

    • Parameters

      • params: OptionalDefaults<GetWebhookParams>

      Returns Promise<WebhookHealthProps>

  • getMany: function

    • getMany(params: OptionalDefaults<GetSpaceParams & QueryParams>): Promise<CollectionProp<WebhookProps>>

    • Parameters

      • params: OptionalDefaults<GetSpaceParams & QueryParams>

      Returns Promise<CollectionProp<WebhookProps>>

  • getManyCallDetails: function

    • getManyCallDetails(params: OptionalDefaults<GetWebhookParams & QueryParams>): Promise<CollectionProp<WebhookCallOverviewProps>>

    • Parameters

      • params: OptionalDefaults<GetWebhookParams & QueryParams>

      Returns Promise<CollectionProp<WebhookCallOverviewProps>>

  • update: function

    • update(params: OptionalDefaults<GetWebhookParams>, rawData: CreateWebhooksProps): Promise<WebhookProps>

    • Parameters

      • params: OptionalDefaults<GetWebhookParams>

      • rawData: CreateWebhooksProps

      Returns Promise<WebhookProps>