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

package/dist/cjs/entities/environment-alias.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ */
+function createEnvironmentAliasApi(makeRequest) {
+    const getParams = (alias) => ({
+        spaceId: alias.sys.space.sys.id,
+        environmentAliasId: alias.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentAlias',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapEnvironmentAlias(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'EnvironmentAlias',
+                action: 'delete',
+                params: getParams(raw),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias data
+ * @return Wrapped environment alias data
+ */
+function wrapEnvironmentAlias(makeRequest, data) {
+    const alias = contentfulSdkCore.toPlainObject(copy(data));
+    const enhancedAlias = enhanceWithMethods(alias, createEnvironmentAliasApi(makeRequest));
+    return contentfulSdkCore.freezeSys(enhancedAlias);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw environment alias collection data
+ * @return Wrapped environment alias collection data
+ */
+const wrapEnvironmentAliasCollection = commonUtils.wrapCollection(wrapEnvironmentAlias);
+
+exports.wrapEnvironmentAlias = wrapEnvironmentAlias;
+exports.wrapEnvironmentAliasCollection = wrapEnvironmentAliasCollection;

package/dist/cjs/entities/environment-template-installation.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+
+var EnvironmentTemplateInstallationStatuses;
+(function (EnvironmentTemplateInstallationStatuses) {
+    EnvironmentTemplateInstallationStatuses["created"] = "created";
+    EnvironmentTemplateInstallationStatuses["inProgress"] = "inProgress";
+    EnvironmentTemplateInstallationStatuses["failed"] = "failed";
+    EnvironmentTemplateInstallationStatuses["succeeded"] = "succeeded";
+    EnvironmentTemplateInstallationStatuses["disconnected"] = "disconnected";
+    EnvironmentTemplateInstallationStatuses["inRetry"] = "inRetry";
+})(EnvironmentTemplateInstallationStatuses || (EnvironmentTemplateInstallationStatuses = {}));
+function wrapEnvironmentTemplateInstallation(makeRequest, data) {
+    const environmentTemplate = contentfulSdkCore.toPlainObject(copy(data));
+    return contentfulSdkCore.freezeSys(environmentTemplate);
+}
+const wrapEnvironmentTemplateInstallationCollection = commonUtils.wrapCursorPaginatedCollection(wrapEnvironmentTemplateInstallation);
+
+exports.wrapEnvironmentTemplateInstallation = wrapEnvironmentTemplateInstallation;
+exports.wrapEnvironmentTemplateInstallationCollection = wrapEnvironmentTemplateInstallationCollection;

package/dist/cjs/entities/environment-template.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var createEnvironmentTemplateApi = require('../create-environment-template-api.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+function wrapEnvironmentTemplate(makeRequest, data, organizationId) {
+    const environmentTemplate = contentfulSdkCore.toPlainObject(copy(data));
+    const environmentTemplateApi = createEnvironmentTemplateApi.createEnvironmentTemplateApi(makeRequest, organizationId);
+    const enhancedEnvironmentTemplate = enhanceWithMethods(environmentTemplate, environmentTemplateApi);
+    return contentfulSdkCore.freezeSys(enhancedEnvironmentTemplate);
+}
+const wrapEnvironmentTemplateCollection = commonUtils.wrapCursorPaginatedCollection(wrapEnvironmentTemplate);
+
+exports.wrapEnvironmentTemplate = wrapEnvironmentTemplate;
+exports.wrapEnvironmentTemplateCollection = wrapEnvironmentTemplateCollection;

package/dist/cjs/entities/environment.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var createEnvironmentApi = require('../create-environment-api.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * This method creates the API for the given environment with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with a environment id, so the base path for requests now has the
+ * environment id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for a Environment
+ * @return
+ */
+function wrapEnvironment(makeRequest, data) {
+    // do not pollute generated typings
+    const environment = contentfulSdkCore.toPlainObject(copy(data));
+    const environmentApi = createEnvironmentApi(makeRequest);
+    const enhancedEnvironment = enhanceWithMethods(environment, environmentApi);
+    return contentfulSdkCore.freezeSys(enhancedEnvironment);
+}
+/**
+ * This method wraps each environment in a collection with the environment API. See wrapEnvironment
+ * above for more details.
+ * @private
+ */
+const wrapEnvironmentCollection = commonUtils.wrapCollection(wrapEnvironment);
+
+exports.wrapEnvironment = wrapEnvironment;
+exports.wrapEnvironmentCollection = wrapEnvironmentCollection;

package/dist/cjs/entities/extension.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ */
+function createExtensionApi(makeRequest) {
+    const getParams = (data) => ({
+        spaceId: data.sys.space.sys.id,
+        environmentId: data.sys.environment.sys.id,
+        extensionId: data.sys.id,
+    });
+    return {
+        update: function update() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Extension',
+                action: 'update',
+                params: getParams(data),
+                payload: data,
+            }).then((response) => wrapExtension(makeRequest, response));
+        },
+        delete: function del() {
+            const data = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Extension',
+                action: 'delete',
+                params: getParams(data),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw UI Extension data
+ * @return Wrapped UI Extension data
+ */
+function wrapExtension(makeRequest, data) {
+    const extension = contentfulSdkCore.toPlainObject(copy(data));
+    const extensionWithMethods = enhanceWithMethods(extension, createExtensionApi(makeRequest));
+    return contentfulSdkCore.freezeSys(extensionWithMethods);
+}
+/**
+ * @private
+ */
+const wrapExtensionCollection = commonUtils.wrapCollection(wrapExtension);
+
+exports.wrapExtension = wrapExtension;
+exports.wrapExtensionCollection = wrapExtensionCollection;

package/dist/cjs/entities/function-log.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+function wrapFunctionLog(makeRequest, data) {
+    const functionLog = contentfulSdkCore.toPlainObject(copy(data));
+    return contentfulSdkCore.freezeSys(functionLog);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - raw contentful-function data
+ * @return Wrapped App Function collection data
+ */
+const wrapFunctionLogCollection = commonUtils.wrapCollection(wrapFunctionLog);
+
+exports.wrapFunctionLog = wrapFunctionLog;
+exports.wrapFunctionLogCollection = wrapFunctionLogCollection;

package/dist/cjs/entities/function.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+
+/**
+ * @private
+ */
+function createFunctionApi(makeRequest) {
+    return {
+        getFunction: function getFunction() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Function',
+                action: 'get',
+                params: {
+                    organizationId: raw.sys.organization.sys.id,
+                    appDefinitionId: raw.sys.appDefinition.sys.id,
+                    functionId: raw.sys.id,
+                },
+            }).then((data) => wrapFunction(makeRequest, data));
+        },
+        getManyFunctions: function getManyFunctions() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Function',
+                action: 'getMany',
+                params: {
+                    appDefinitionId: raw.sys.appDefinition.sys.id,
+                    organizationId: raw.sys.organization.sys.id,
+                },
+            }).then((data) => wrapFunctionCollection(makeRequest, data));
+        },
+        getManyFunctionsForEnvironment(spaceId, environmentId, appInstallationId) {
+            return makeRequest({
+                entityType: 'Function',
+                action: 'getManyForEnvironment',
+                params: {
+                    spaceId: spaceId,
+                    environmentId: environmentId,
+                    appInstallationId: appInstallationId,
+                },
+            }).then((data) => wrapFunctionCollection(makeRequest, data));
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - (real) function to make requests via an adapter
+ * @param data - raw contentful-Function data
+ * @return Wrapped Function data
+ */
+function wrapFunction(makeRequest, data) {
+    const func = contentfulSdkCore.toPlainObject(copy(data));
+    const funcWithMethods = enhanceWithMethods(func, createFunctionApi(makeRequest));
+    return contentfulSdkCore.freezeSys(funcWithMethods);
+}
+/**
+ * @private
+ */
+const wrapFunctionCollection = commonUtils.wrapCollection(wrapFunction);
+
+exports.wrapFunction = wrapFunction;
+exports.wrapFunctionCollection = wrapFunctionCollection;

package/dist/cjs/entities/index.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+var aiAction = require('./ai-action.js');
+var aiActionInvocation = require('./ai-action-invocation.js');
+var apiKey = require('./api-key.js');
+var appAction = require('./app-action.js');
+var appActionCall = require('./app-action-call.js');
+var appBundle = require('./app-bundle.js');
+var appDefinition = require('./app-definition.js');
+var appDetails = require('./app-details.js');
+var appInstallation = require('./app-installation.js');
+var appSignedRequest = require('./app-signed-request.js');
+var appSigningSecret = require('./app-signing-secret.js');
+var appEventSubscription = require('./app-event-subscription.js');
+var appKey = require('./app-key.js');
+var appAccessToken = require('./app-access-token.js');
+var appUpload = require('./app-upload.js');
+var asset = require('./asset.js');
+var assetKey = require('./asset-key.js');
+var bulkAction = require('./bulk-action.js');
+var comment = require('./comment.js');
+var contentType = require('./content-type.js');
+var editorInterface = require('./editor-interface.js');
+var entry = require('./entry.js');
+var environment = require('./environment.js');
+var environmentAlias = require('./environment-alias.js');
+var environmentTemplate = require('./environment-template.js');
+var environmentTemplateInstallation = require('./environment-template-installation.js');
+var extension = require('./extension.js');
+var _function = require('./function.js');
+var functionLog = require('./function-log.js');
+var locale = require('./locale.js');
+var oauthApplication = require('./oauth-application.js');
+var organization = require('./organization.js');
+var organizationInvitation = require('./organization-invitation.js');
+var organizationMembership = require('./organization-membership.js');
+var personalAccessToken = require('./personal-access-token.js');
+var accessToken = require('./access-token.js');
+var previewApiKey = require('./preview-api-key.js');
+var release = require('./release.js');
+var releaseAction = require('./release-action.js');
+var role = require('./role.js');
+var scheduledAction = require('./scheduled-action.js');
+var snapshot = require('./snapshot.js');
+var space = require('./space.js');
+var spaceMember = require('./space-member.js');
+var spaceMembership = require('./space-membership.js');
+var tag = require('./tag.js');
+var task = require('./task.js');
+var team = require('./team.js');
+var teamMembership = require('./team-membership.js');
+var teamSpaceMembership = require('./team-space-membership.js');
+var uiConfig = require('./ui-config.js');
+var upload = require('./upload.js');
+var usage = require('./usage.js');
+var user = require('./user.js');
+var userUiConfig = require('./user-ui-config.js');
+var webhook = require('./webhook.js');
+var workflowDefinition = require('./workflow-definition.js');
+var concept = require('./concept.js');
+var conceptScheme = require('./concept-scheme.js');
+var resourceProvider = require('./resource-provider.js');
+var resourceType = require('./resource-type.js');
+var resource = require('./resource.js');
+
+var entities = {
+    aiAction,
+    aiActionInvocation,
+    accessToken,
+    appAction,
+    appActionCall,
+    appBundle,
+    apiKey,
+    appDefinition,
+    appInstallation,
+    appUpload,
+    appDetails,
+    appSignedRequest,
+    appSigningSecret,
+    appEventSubscription,
+    appKey,
+    appAccessToken,
+    asset,
+    assetKey,
+    bulkAction,
+    comment,
+    concept,
+    conceptScheme,
+    contentType,
+    editorInterface,
+    entry,
+    environment,
+    environmentAlias,
+    environmentTemplate,
+    environmentTemplateInstallation,
+    extension,
+    func: _function,
+    functionLog,
+    locale,
+    oauthApplication,
+    organization,
+    organizationInvitation,
+    organizationMembership,
+    personalAccessToken,
+    previewApiKey,
+    release,
+    releaseAction,
+    resourceProvider,
+    resourceType,
+    resource,
+    role,
+    scheduledAction,
+    snapshot,
+    space,
+    spaceMember,
+    spaceMembership,
+    tag,
+    task,
+    team,
+    teamMembership,
+    teamSpaceMembership,
+    uiConfig,
+    upload,
+    usage,
+    user,
+    userUIConfig: userUiConfig,
+    webhook,
+    workflowDefinition,
+};
+
+module.exports = entities;

package/dist/cjs/entities/locale.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ */
+function createLocaleApi(makeRequest) {
+    const getParams = (locale) => ({
+        spaceId: locale.sys.space.sys.id,
+        environmentId: locale.sys.environment.sys.id,
+        localeId: locale.sys.id,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Locale',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapLocale(makeRequest, data));
+        },
+        delete: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'Locale',
+                action: 'delete',
+                params: getParams(raw),
+            }).then(() => {
+                // noop
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw locale data
+ * @return Wrapped locale data
+ */
+function wrapLocale(makeRequest, data) {
+    delete data.internal_code;
+    const locale = contentfulSdkCore.toPlainObject(copy(data));
+    const localeWithMethods = enhanceWithMethods(locale, createLocaleApi(makeRequest));
+    return contentfulSdkCore.freezeSys(localeWithMethods);
+}
+/**
+ * @private
+ */
+const wrapLocaleCollection = commonUtils.wrapCollection(wrapLocale);
+
+exports.wrapLocale = wrapLocale;
+exports.wrapLocaleCollection = wrapLocaleCollection;

package/dist/cjs/entities/oauth-application.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var copy = require('fast-copy');
+var commonUtils = require('../common-utils.js');
+
+exports.ScopeValues = void 0;
+(function (ScopeValues) {
+    ScopeValues["Read"] = "content_management_read";
+    ScopeValues["Manage"] = "content_management_manage";
+})(exports.ScopeValues || (exports.ScopeValues = {}));
+/**
+ * @private
+ */
+function createOAuthApplicationApi(makeRequest, userId) {
+    const getParams = (data) => ({
+        userId,
+        oauthApplicationId: data.sys.id,
+    });
+    return {
+        /**
+         * Updates an OAuth application
+         * @return Promise for the updated OAuth application
+         */
+        async update() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OAuthApplication',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            });
+        },
+        /**
+         * Deletes an OAuth application
+         * @return Promise for the deleted OAuth application
+         */
+        async delete() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OAuthApplication',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw OAuth application data
+ * @return Wrapped OAuth application data
+ */
+function wrapOAuthApplication(makeRequest, data, userId) {
+    const oauthApplication = contentfulSdkCore.toPlainObject(copy(data));
+    const oauthApplicationWithMethods = enhanceWithMethods(oauthApplication, createOAuthApplicationApi(makeRequest, userId));
+    return contentfulSdkCore.freezeSys(oauthApplicationWithMethods);
+}
+/**
+ * @private
+ */
+const wrapOAuthApplicationCollection = commonUtils.wrapCursorPaginatedCollection(wrapOAuthApplication);
+
+exports.wrapOAuthApplication = wrapOAuthApplication;
+exports.wrapOAuthApplicationCollection = wrapOAuthApplicationCollection;

package/dist/cjs/entities/organization-invitation.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var contentfulSdkCore = require('contentful-sdk-core');
+var copy = require('fast-copy');
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw invitation data
+ * @return {OrganizationInvitation} Wrapped Inviation data
+ */
+function wrapOrganizationInvitation(_makeRequest, data) {
+    const invitation = contentfulSdkCore.toPlainObject(copy(data));
+    return contentfulSdkCore.freezeSys(invitation);
+}
+
+exports.wrapOrganizationInvitation = wrapOrganizationInvitation;

package/dist/cjs/entities/organization-membership.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ */
+function createOrganizationMembershipApi(makeRequest, organizationId) {
+    const getParams = (data) => ({
+        organizationMembershipId: data.sys.id,
+        organizationId,
+    });
+    return {
+        update: function () {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OrganizationMembership',
+                action: 'update',
+                params: getParams(raw),
+                payload: raw,
+            }).then((data) => wrapOrganizationMembership(makeRequest, data, organizationId));
+        },
+        delete: function del() {
+            const raw = this.toPlainObject();
+            return makeRequest({
+                entityType: 'OrganizationMembership',
+                action: 'delete',
+                params: getParams(raw),
+            });
+        },
+    };
+}
+/**
+ * @private
+ * @param {function} makeRequest - function to make requests via an adapter
+ * @param {Object} data - Raw organization membership data
+ * @return {OrganizationMembership} Wrapped organization membership data
+ */
+function wrapOrganizationMembership(makeRequest, data, organizationId) {
+    const organizationMembership = contentfulSdkCore.toPlainObject(copy(data));
+    const organizationMembershipWithMethods = enhanceWithMethods(organizationMembership, createOrganizationMembershipApi(makeRequest, organizationId));
+    return contentfulSdkCore.freezeSys(organizationMembershipWithMethods);
+}
+/**
+ * @private
+ */
+const wrapOrganizationMembershipCollection = commonUtils.wrapCollection(wrapOrganizationMembership);
+
+exports.wrapOrganizationMembership = wrapOrganizationMembership;
+exports.wrapOrganizationMembershipCollection = wrapOrganizationMembershipCollection;

package/dist/cjs/entities/organization.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var createOrganizationApi = require('../create-organization-api.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * This method creates the API for the given organization with all the methods for
+ * reading and creating other entities. It also passes down a clone of the
+ * http client with an organization id, so the base path for requests now has the
+ * organization id already set.
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - API response for an Organization
+ * @return {Organization}
+ */
+function wrapOrganization(makeRequest, data) {
+    const org = contentfulSdkCore.toPlainObject(copy(data));
+    const orgApi = createOrganizationApi(makeRequest);
+    const enhancedOrganization = enhanceWithMethods(org, orgApi);
+    return contentfulSdkCore.freezeSys(enhancedOrganization);
+}
+/**
+ * This method normalizes each organization in a collection.
+ * @private
+ */
+const wrapOrganizationCollection = commonUtils.wrapCollection(wrapOrganization);
+
+exports.wrapOrganization = wrapOrganization;
+exports.wrapOrganizationCollection = wrapOrganizationCollection;

package/dist/cjs/entities/personal-access-token.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var copy = require('fast-copy');
+var contentfulSdkCore = require('contentful-sdk-core');
+var enhanceWithMethods = require('../enhance-with-methods.js');
+var commonUtils = require('../common-utils.js');
+
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw  personal access token data
+ * @return Wrapped personal access token
+ */
+function wrapPersonalAccessToken(makeRequest, data) {
+    const personalAccessToken = contentfulSdkCore.toPlainObject(copy(data));
+    const personalAccessTokenWithMethods = enhanceWithMethods(personalAccessToken, {
+        revoke: function () {
+            return makeRequest({
+                entityType: 'PersonalAccessToken',
+                action: 'revoke',
+                params: { tokenId: data.sys.id },
+            }).then((data) => wrapPersonalAccessToken(makeRequest, data));
+        },
+    });
+    return contentfulSdkCore.freezeSys(personalAccessTokenWithMethods);
+}
+/**
+ * @private
+ * @param makeRequest - function to make requests via an adapter
+ * @param data - Raw personal access collection data
+ * @return Wrapped personal access token collection data
+ */
+const wrapPersonalAccessTokenCollection = commonUtils.wrapCollection(wrapPersonalAccessToken);
+
+exports.wrapPersonalAccessToken = wrapPersonalAccessToken;
+exports.wrapPersonalAccessTokenCollection = wrapPersonalAccessTokenCollection;