@nascentdigital/funnel-cms 4.4.4

package/dist/strapi/StrapiCollectionClient.js

@@ -0,0 +1,610 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiCollectionClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const errors_1 = require("../errors");
+const serialization_1 = require("./serialization");
+const Strapi_1 = require("./Strapi");
+// class
+class StrapiCollectionClient {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    getOverview({ brand, version }) {
+        return this.provider.customRequest({
+            command: 'query/collections',
+            params: { brand, preview: version === 'draft' ? 'true' : 'false' }
+        });
+    }
+    async getItems({ brand, type, language, tags, version }) {
+        // create params (add tags if any)
+        const params = {
+            brand,
+            type,
+            language,
+            preview: version === 'draft' ? 'true' : 'false'
+        };
+        if (tags && tags.length > 0) {
+            params.tags = tags.join(',');
+        }
+        const itemsData = await this.provider.customRequest({
+            command: 'query/collection',
+            params
+        });
+        // convert refs and return
+        return itemsData.map((_a) => {
+            var { refs } = _a, itemData = __rest(_a, ["refs"]);
+            return (Object.assign(Object.assign({}, itemData), { refs: Object.values(refs).reduce((refs, ref) => {
+                    // map ref
+                    refs[ref.lang] = serialization_1.CollectionData.deserializeRef(ref);
+                    // keep reducing
+                    return refs;
+                }, {}) }));
+        });
+    }
+    async find(_a) {
+        var { pagination } = _a, args = __rest(_a, ["pagination"]);
+        // fetch all pages that match (as link data)
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('collections');
+        const resultProps = funnel_core_1.Schema.Collection.Data.Props.all;
+        const _b = await Strapi_1.Strapi.paginate(Object.assign({ collection,
+            pagination, fields: serialization_1.CollectionData.getStrapiFilter(resultProps), sort: args.version === 'published'
+                ? ['publishedOn:desc', 'updatedAt:desc']
+                : ['updatedAt:desc'], populate: serialization_1.CollectionData.populate }, getCollectionQueryParams(args))), { items } = _b, paginated = __rest(_b, ["items"]);
+        // transform to DTOs
+        return Object.assign({ items: items.map(item => serialization_1.CollectionData.deserialize(item, strapiUrl, resultProps)) }, paginated);
+    }
+    async getGroup({ version, type, brand, groupId, language }) {
+        var _a, _b;
+        // fetch all collection items in group
+        const client = this.provider.client;
+        const collection = client.collection('collections');
+        const { items = [] } = await Strapi_1.Strapi.paginate(Object.assign({ collection, pagination: 'all', fields: serialization_1.CollectionData.getStrapiFilter(funnel_core_1.Schema.Collection.Data.Props.id) }, getCollectionQueryParams({ version, brand, groupId })));
+        // return nothing if there are no instances
+        if (items.length === 0) {
+            return undefined;
+        }
+        // create group
+        const schema = funnel_core_1.Schema.Site.getCollection(type);
+        const instances = items.map(serialization_1.CollectionData.deserializeRef);
+        const result = {
+            group: {
+                type,
+                brand,
+                groupId,
+                name: (_b = (_a = funnel_core_1.ArrayUtils.first(items)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : schema.name,
+                instances
+            }
+        };
+        // add language if it exists as an instance
+        const target = instances.find(item => item.language === language);
+        if (target) {
+            // get collection
+            result.collection = await this.get({ version, id: target.id });
+            // sync name if collection was found
+            if (result.collection) {
+                result.group.name = result.collection.name;
+            }
+        }
+        // return result
+        return result;
+    }
+    async get({ version, id }) {
+        // get data
+        const client = this.provider.client;
+        const resultProps = funnel_core_1.Schema.Collection.Data.Props.all;
+        const { data } = await client.collection('collections').findOne(id, {
+            fields: serialization_1.CollectionData.getStrapiFilter(resultProps),
+            status: version,
+            populate: serialization_1.CollectionData.populate
+        });
+        // deserialize and return
+        return data
+            ? serialization_1.CollectionData.deserialize(data, client.baseURL, resultProps)
+            : undefined;
+    }
+    async create(args) {
+        // resolve current user (or throw)
+        const { client, users } = this.provider;
+        const strapiUrl = client.baseURL;
+        const user = await users.me();
+        if (!user) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // create a new language of an existing collection
+        if (funnel_core_1.Schema.Collection.Data.AsNewLanguage.filter(args)) {
+            // fetch all collections in group
+            const groupResult = await this.getGroup({
+                version: 'draft',
+                type: args.type,
+                groupId: args.groupId,
+                language: args.language
+            });
+            // throw if the group doesn't exist
+            if (groupResult === undefined) {
+                throw new funnel_core_1.ArgumentError(`Collection group "${args.groupId}" no longer exists in "${args.brand}"`);
+            }
+            // extract group and existing collection from result
+            const { group, collection: existingCollection } = groupResult;
+            // return existing collection if it's there
+            if (existingCollection) {
+                return {
+                    group,
+                    collection: existingCollection
+                };
+            }
+            // bind data + update url
+            const draft = funnel_core_1.Schema.CollectionModel.fromDraft(Object.assign(Object.assign({}, args), { type: group.type, name: group.name, tags: [] }));
+            draft.sync();
+            // resolve change set (rebind)
+            const { provider } = this;
+            const changeSet = await provider.changeSets.resolve();
+            // create collection
+            try {
+                // connect collection to changeset
+                draft.data.changeSetId = changeSet.id;
+                // create data model based on existing page
+                const { data } = await client.collection('collections')
+                    .create(serialization_1.CollectionData.serialize(draft.data), {
+                    status: 'draft',
+                    populate: serialization_1.CollectionData.populate
+                });
+                // transform the deserialized entry
+                const collection = serialization_1.CollectionData.deserialize(data, strapiUrl, funnel_core_1.Schema.Collection.Data.Props.all);
+                // add collection to changeset
+                await provider.changeSets.update({
+                    id: changeSet.id,
+                    changes: [
+                        ...changeSet.changes,
+                        {
+                            __type: 'collection',
+                            type: 'create',
+                            schema: collection.type,
+                            id: collection.id,
+                            groupId: collection.groupId,
+                            name: collection.name,
+                            language: collection.language,
+                            errors: collection.errors,
+                            attribution: [
+                                { userId: user.id, updatedOn: Date.now() }
+                            ]
+                        }
+                    ]
+                });
+                // add collection to group
+                group.instances.push({
+                    id: collection.id,
+                    language: collection.language,
+                    version: collection.version,
+                    tags: collection.tags
+                });
+                // return updated group
+                return {
+                    group,
+                    collection
+                };
+            }
+            // or remove on failure remove
+            catch (e) {
+                // discard if it had no changes
+                if (changeSet.changes.length === 0) {
+                    await provider.changeSets.delete(changeSet.id);
+                }
+                // throw error
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
+        // or create a net new collection
+        else {
+            // bind data + update url
+            const draft = funnel_core_1.Schema.CollectionModel.fromDraft(Object.assign(Object.assign({}, args), { groupId: funnel_core_1.Value.uuid() }));
+            draft.sync();
+            console.debug('[StrapiCollectionClient/create/new] creating new draft', serialization_1.CollectionData.serialize(draft.data));
+            // resolve change set (rebind)
+            const { provider } = this;
+            const changeSet = await provider.changeSets.resolve();
+            // or create it
+            try {
+                // connect collection to changeset
+                draft.data.changeSetId = changeSet.id;
+                // create collection
+                const { data } = await client.collection('collections')
+                    .create(serialization_1.CollectionData.serialize(draft.data), {
+                    status: 'draft',
+                    populate: serialization_1.CollectionData.populate
+                });
+                // transform the deserialized entry
+                const collection = serialization_1.CollectionData.deserialize(data, strapiUrl, funnel_core_1.Schema.Collection.Data.Props.all);
+                // add collection to changeset
+                await provider.changeSets.update({
+                    id: changeSet.id,
+                    changes: [
+                        ...changeSet.changes,
+                        {
+                            __type: 'collection',
+                            type: 'create',
+                            schema: collection.type,
+                            id: collection.id,
+                            groupId: collection.groupId,
+                            name: collection.name,
+                            language: collection.language,
+                            errors: collection.errors,
+                            attribution: [
+                                { userId: user.id, updatedOn: Date.now() }
+                            ]
+                        }
+                    ]
+                });
+                // return collection
+                return {
+                    group: {
+                        groupId: collection.groupId,
+                        brand: collection.brand,
+                        type: collection.type,
+                        name: collection.name,
+                        instances: [{
+                                id: collection.id,
+                                language: collection.language,
+                                version: collection.version,
+                                tags: collection.tags
+                            }]
+                    },
+                    collection
+                };
+            }
+            // or remove on failure remove
+            catch (e) {
+                // discard if it had no changes
+                if (changeSet.changes.length === 0) {
+                    await provider.changeSets.delete(changeSet.id);
+                }
+                // throw error
+                throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+            }
+        }
+    }
+    async duplicate({ source: collectionId, targetCollection, targetLanguage }) {
+        // resolve current user (or throw)
+        const { client, users } = this.provider;
+        const strapiUrl = client.baseURL;
+        const user = await users.me();
+        if (!user) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // get collection by id
+        const collectionCollection = client.collection('collections');
+        const { data: sourceData } = await collectionCollection.findOne(collectionId, {
+            fields: serialization_1.CollectionData.getStrapiFilter(funnel_core_1.Schema.Collection.Data.Props.all),
+            status: 'draft',
+            populate: serialization_1.CollectionData.populate
+        });
+        const sourceCollection = sourceData;
+        // throw if there's no collection
+        if (!sourceCollection) {
+            throw new funnel_core_1.NotFoundError(`Unable to resolve collection with id "${collectionId}"`);
+        }
+        // make sure target language doesn't already exist if we are targeting the current group
+        if (targetCollection === 'current') {
+            const { data: collectionsWithTargetLanguage } = await collectionCollection.find(Object.assign({ fields: ['documentId'] }, getCollectionQueryParams({ version: 'draft', groupId: sourceCollection.groupId, language: targetLanguage })));
+            if (collectionsWithTargetLanguage.length > 0) {
+                throw new funnel_core_1.InvalidOperationError(`There is already a collection in group "${sourceCollection.groupId}" with ${targetLanguage} language`);
+            }
+        }
+        // get refs from source collection
+        const { assetRefs, collectionRefs } = sourceCollection;
+        // target refs and body
+        let targetCollectionRefIds;
+        let targetBody;
+        // if we are targeting a different language then we need to "translate" the references
+        if (targetLanguage !== sourceCollection.lang) {
+            // fetch target language refs
+            const { collectionIdMappings } = await Strapi_1.Strapi.translateReferences({
+                client,
+                targetLanguage,
+                collectionRefs
+            });
+            // set target values
+            targetCollectionRefIds = collectionIdMappings.map(mapping => mapping.targetId);
+            targetBody = {
+                fields: Strapi_1.Strapi.updateRefs({ value: sourceCollection.fields, collectionIdMappings })
+            };
+        }
+        // otherwise we can keep everything the same as the source page
+        else {
+            // set target values
+            targetCollectionRefIds = collectionRefs.map(ref => ref.documentId);
+            targetBody = {
+                fields: sourceCollection.fields
+            };
+        }
+        // resolve change set (rebind)
+        const { provider } = this;
+        const changeSet = await provider.changeSets.resolve();
+        // create duplicate collection
+        try {
+            // create target collection using content of source
+            const { data: dupData } = await collectionCollection.create(Object.assign({ groupId: targetCollection === 'current'
+                    ? sourceCollection.groupId
+                    : funnel_core_1.Value.uuid(), version: 1, type: sourceCollection.type, brand: sourceCollection.brand, lang: targetLanguage, name: sourceCollection.name, tags: sourceCollection.tags, state: 'draft', errors: sourceCollection.errors, assetRefs: { set: assetRefs.map(ref => ref.documentId) }, collectionRefs: { set: targetCollectionRefIds } }, targetBody), { status: 'draft', populate: serialization_1.CollectionData.populate });
+            const dupCollectionData = dupData;
+            console.debug('[StrapiCollectionClient] duplicate: created duplicate collection', { dupCollectionData });
+            // touch new duplicated collection
+            let dupCollection = serialization_1.CollectionData.deserialize(dupCollectionData, strapiUrl, funnel_core_1.Schema.Collection.Data.Props.all);
+            const dupCollectionModel = funnel_core_1.Schema.CollectionModel.from(dupCollection);
+            dupCollectionModel.sync();
+            // connect collection to changeset
+            dupCollection.changeSetId = changeSet.id;
+            // update duplicate collection with updated data from sync
+            const update = serialization_1.CollectionData.serialize(dupCollection);
+            const { data: updatedData } = await collectionCollection.update(dupCollection.id, update, { status: 'draft' });
+            dupCollection = serialization_1.CollectionData.deserialize(updatedData, strapiUrl, funnel_core_1.Schema.Collection.Data.Props.all);
+            console.debug('[StrapiCollectionClient] duplicate: touched duplicated collection');
+            // add collection to changeset
+            await provider.changeSets.update({
+                id: changeSet.id,
+                changes: [
+                    ...changeSet.changes,
+                    {
+                        __type: 'collection',
+                        type: 'create',
+                        schema: dupCollection.type,
+                        id: dupCollection.id,
+                        groupId: dupCollection.groupId,
+                        name: dupCollection.name,
+                        language: dupCollection.language,
+                        errors: dupCollection.errors,
+                        attribution: [
+                            { userId: user.id, updatedOn: Date.now() }
+                        ]
+                    }
+                ]
+            });
+            // return group for duplicated collection
+            const group = await this.getGroup({
+                brand: dupCollection.brand,
+                groupId: dupCollection.groupId,
+                type: dupCollection.type,
+                language: dupCollection.language,
+                version: 'draft'
+            });
+            // should not happen
+            if (!group) {
+                throw new funnel_core_1.IllegalStateError(`cannot find group that was just created`);
+            }
+            // return
+            return group;
+        }
+        // handle errors
+        catch (e) {
+            // discard changeset if it had no changes
+            if (changeSet.changes.length === 0) {
+                await provider.changeSets.delete(changeSet.id);
+            }
+            // throw error
+            throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+        }
+    }
+    async update({ id: collectionId, errors, updates }) {
+        // resolve current user (or throw)
+        const { client, users } = this.provider;
+        const strapiUrl = client.baseURL;
+        const user = await users.me();
+        if (!user) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // get latest version of collection
+        const entries = client.collection('collections');
+        const resultProps = funnel_core_1.Schema.Collection.Data.Props.all;
+        const { data: currentData } = await entries.findOne(collectionId, {
+            status: 'draft',
+            populate: serialization_1.CollectionData.populate
+        });
+        // TODO: validate collection is able to be updated (e.g. not archived, etc.)
+        // TODO: switch to isometric error so we can catch it on client-side
+        // throw if collection doesn't exist
+        if (!currentData) {
+            throw new funnel_core_1.NotFoundError();
+        }
+        // deserialize collection (we'll be updating this version)
+        const collection = serialization_1.CollectionData.deserialize(currentData, strapiUrl, resultProps);
+        // set errors
+        collection.errors = errors;
+        console.debug(`[StrapiPageClient/update] applying ${updates.length} collection updates`);
+        // merge changes (the original collection will have changed)
+        const model = funnel_core_1.Schema.CollectionModel.from(collection);
+        model.update(updates);
+        console.debug(`[StrapiPageClient/update] saving updated collection`);
+        // resolve change set (rebind)
+        const { provider } = this;
+        const changeSet = await provider.changeSets.resolve({ id: collection.changeSetId, fallbackToGlobal: true });
+        collection.changeSetId = changeSet.id;
+        // save collection
+        const update = serialization_1.CollectionData.serialize(collection);
+        const { data: updatedData } = await entries.update(collection.id, Object.assign(Object.assign({}, update), { state: 'draft' }), {
+            status: 'draft',
+            populate: serialization_1.CollectionData.populate
+        });
+        // update changeset
+        changeSet.addCollectionChange(user.id, {
+            __type: 'collection',
+            id: collection.id,
+            groupId: collection.groupId,
+            name: collection.name,
+            schema: collection.type,
+            language: collection.language,
+            type: collection.publishedOn ? 'update' : 'create',
+            errors: collection.errors
+        });
+        provider.changeSets.update(changeSet.toData())
+            .catch(console.error);
+        // return collection
+        return serialization_1.CollectionData.deserialize(updatedData, strapiUrl, resultProps);
+    }
+    async replace({ updatedCollection, version, skipSync }) {
+        console.debug(`[StrapiCollectionClient/replace] replacing collection`);
+        // get latest version of collection
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('collection');
+        // sync changes (the original collection will have changed)
+        const model = funnel_core_1.Schema.CollectionModel.from(updatedCollection);
+        if (!skipSync) {
+            model.sync();
+        }
+        // save collection
+        const update = serialization_1.CollectionData.serialize(updatedCollection);
+        const { data: updatedData } = await collection.update(updatedCollection.id, update, {
+            status: version,
+            populate: serialization_1.CollectionData.populate
+        });
+        console.debug(`[StrapiCollectionClient/replace] returning final collection`);
+        // return collection
+        return serialization_1.CollectionData.deserialize(updatedData, strapiUrl);
+    }
+    async unpublish(collectionId) {
+        // get collection
+        const collection = await this.get({ id: collectionId, version: 'draft' });
+        // throw if there's no collection
+        if (!collection) {
+            throw new funnel_core_1.NotFoundError('Unable to resolve collection');
+        }
+        // or throw if it's already draft
+        else if (!collection.publishedOn) {
+            throw new funnel_core_1.InvalidOperationError('Collection is not published');
+        }
+        // unpublish the document
+        await this.provider.customRequest({
+            method: 'POST',
+            command: 'unpublish',
+            data: JSON.stringify({
+                collection: 'collection',
+                documentId: collection.id
+            }),
+            onError: ({ pageRefs, collectionRefs }) => {
+                // throw dependants error if we got any refs
+                if (pageRefs || collectionRefs) {
+                    const client = this.provider.client;
+                    const strapiUrl = client.baseURL;
+                    throw new errors_1.LinkedDependantsError({
+                        message: 'This collection cannot be unpublished because it would break dependencies',
+                        pages: pageRefs.map(data => serialization_1.PageData.deserialize(data, strapiUrl, funnel_core_1.Schema.Page.Data.AsLink.props)),
+                        collections: collectionRefs.map(data => serialization_1.CollectionData.deserialize(data, strapiUrl, funnel_core_1.Schema.Collection.Data.AsLink.props))
+                    });
+                }
+                // or assume the page isn't published
+                else {
+                    throw new funnel_core_1.NotFoundError();
+                }
+            }
+        });
+        // indicate success
+        return true;
+    }
+    async getDependants({ id: collectionId, version }) {
+        // setup strapi collections and query
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const pagesCollection = client.collection('pages');
+        const collectionsCollection = client.collection('collections');
+        const dependantsQuery = {
+            pagination: 'all',
+            filters: {
+                collectionRefs: {
+                    documentId: collectionId
+                }
+            },
+            status: version
+        };
+        // fetch dependants
+        const [{ items: pages = [] }, { items: collections = [] }] = await Promise.all([
+            Strapi_1.Strapi.paginate(Object.assign({ collection: pagesCollection }, dependantsQuery)),
+            Strapi_1.Strapi.paginate(Object.assign({ collection: collectionsCollection }, dependantsQuery))
+        ]);
+        // return
+        return {
+            pages: pages.map(page => serialization_1.PageData.deserialize(page, strapiUrl, funnel_core_1.Schema.Page.Data.AsRef.props)),
+            collections: collections.map(collection => serialization_1.CollectionData.deserialize(collection, strapiUrl, funnel_core_1.Schema.Collection.Data.AsRef.props))
+        };
+    }
+    async getDependencies({ id: collectionId, version }) {
+        // get collection by id
+        const client = this.provider.client;
+        const strapiUrl = client.baseURL;
+        const collection = client.collection('collections');
+        const { data } = await collection.findOne(collectionId, {
+            status: version,
+            populate: ['collectionRefs']
+        });
+        const collectionData = data;
+        // throw if not found
+        if (!collectionData) {
+            throw new funnel_core_1.NotFoundError(`cannot find collection with id "${collectionId}"`);
+        }
+        // return
+        return {
+            collections: collectionData.collectionRefs.map(collectionRef => serialization_1.CollectionData.deserialize(collectionRef, strapiUrl, funnel_core_1.Schema.Collection.Data.AsRef.props))
+        };
+    }
+}
+exports.StrapiCollectionClient = StrapiCollectionClient;
+// helper
+function getCollectionQueryParams(query) {
+    // build filters
+    const { groupId, brand, type, language, name, tags = [], tagsMatch = 'any', version } = query;
+    const filters = [];
+    // filter group
+    if (groupId) {
+        filters.push({ groupId: { $eq: groupId } });
+    }
+    // filter brand
+    if (brand) {
+        filters.push({ brand: { $eq: brand } });
+    }
+    // filter type
+    const normalizedType = type
+        ? Array.isArray(type)
+            ? type
+            : [type]
+        : [];
+    if (normalizedType.length > 0) {
+        filters.push({ type: { $in: type } });
+    }
+    // filter language
+    if (language) {
+        filters.push({ lang: { $eq: language } });
+    }
+    // filter name
+    if (name) {
+        filters.push({ name: { $contains: name } });
+    }
+    // filter tags
+    if (tags.length === 1) {
+        filters.push({ tags: { $contains: `"${tags[0]}"` } });
+    }
+    else if (tags.length > 1) {
+        const operator = tagsMatch === 'any' ? '$or' : '$and';
+        filters.push({
+            [operator]: tags
+                .filter((tag) => !!tag)
+                .map((tag) => ({ tags: { $contains: `"${tag}"` } }))
+        });
+    }
+    // return query
+    return {
+        filters: filters.length > 0 ? { $and: filters } : undefined,
+        status: version
+    };
+}

package/dist/strapi/StrapiContentClient.d.ts

@@ -0,0 +1,38 @@
+import { StrapiClient } from '@strapi/client';
+import { JsonValue } from 'type-fest';
+import { AuthClient, ContentClient } from '../api';
+import { IStrapiContentClient } from './IStrapiContentClient';
+import { StrapiAssetClient } from './StrapiAssetClient';
+import { StrapiAuthClient } from './StrapiAuthClient';
+import { StrapiChangeSetClient } from './StrapiChangeSetClient';
+import { StrapiCollectionClient } from './StrapiCollectionClient';
+import { StrapiPageClient } from './StrapiPageClient';
+import { StrapiSiteConfigClient } from './StrapiSiteConfigClient';
+import { StrapiUpgradeClient } from './StrapiUpgradeClient';
+import { StrapiUserClient } from './StrapiUserClient';
+export declare class StrapiContentClient implements ContentClient, IStrapiContentClient {
+    readonly auth: StrapiAuthClient;
+    readonly changeSets: StrapiChangeSetClient;
+    readonly files: StrapiAssetClient;
+    readonly pages: StrapiPageClient;
+    readonly collections: StrapiCollectionClient;
+    readonly upgrade: StrapiUpgradeClient;
+    readonly users: StrapiUserClient;
+    readonly siteConfig: StrapiSiteConfigClient;
+    private readonly _baseUrl;
+    private _token?;
+    private _client;
+    constructor({ baseUrl, token, slackUrl }: StrapiContentClient.ConstructorArgs);
+    get client(): StrapiClient;
+    get token(): AuthClient.AccessToken;
+    set token(token: AuthClient.AccessToken);
+    clearToken(): void;
+    customRequest<TResult extends JsonValue = JsonValue, TError extends JsonValue = JsonValue>({ command, method, params, data, onError }: IStrapiContentClient.CustomRequestArgs<TError>): Promise<TResult>;
+}
+export declare namespace StrapiContentClient {
+    type ConstructorArgs = {
+        baseUrl: string;
+        token?: string;
+        slackUrl?: string;
+    };
+}