@stackend/api/cms/index.d.ts

JS bindings to api.stackend.com

import { XcapJsonResult, Thunk, XcapOptionalParameters } from '../api';
import ModerationStatus from '../api/ModerationStatus';
import { PaginatedCollection } from '../api/PaginatedCollection';
import { Insertion, Category } from '../category';
import Order from '../api/Order';
import { Tree, Node } from '../api/tree';
import { ModuleType } from '../stackend/modules';
import XcapObject from '../api/XcapObject';
import PermalinkAware from '../api/PermalinkAware';
import NameAware from '../api/NameAware';
import ModerationAware from '../api/ModerationAware';
import CreatedDateAware from '../api/CreatedDateAware';
import CreatorUserIdAware from '../api/CreatorUserIdAware';
import ModifiedDateAware from '../api/ModifiedDateAware';
import ModifiedByUserIdAware from '../api/ModifiedByUserIdAware';
import PublishDateAware from '../api/PublishDateAware';
/**
 * Xcap Cms api constants and methods.
 *
 * @since 6 feb 2017
 */
/**
 * Css Class for elements containing rich content
 * @type {string}
 */
export declare const RICH_CONTENT_CSS_CLASS = "stackend-rich-content";
/**
 * A content object
 */
export interface Content extends XcapObject, PermalinkAware, NameAware, ModerationAware, CreatedDateAware, CreatorUserIdAware, ModifiedDateAware, ModifiedByUserIdAware, PublishDateAware {
    __type: 'se.josh.xcap.cms.Content';
    body: string;
}
/**
 * Component class (used to look up privileges, etc)
 */
export declare const COMPONENT_CLASS = "se.josh.xcap.cms.CmsManager";
/**
 * Component name
 */
export declare const COMPONENT_NAME = "cms";
/**
 * Default context
 * @type {string}
 */
export declare const DEFAULT_CMS_CONTEXT = "cms";
export interface GetContentResult extends XcapJsonResult {
    content: Content | null;
}
/**
 * Get CMS content
 * @param id Content id (required)
 * @param permalink Content permalink (optional)
 */
export declare function getContent({ id, permalink }: {
    id?: number;
    permalink?: string;
} & XcapOptionalParameters): Thunk<Promise<GetContentResult>>;
export interface PopulateTemplateContent extends XcapJsonResult {
    result: string | null;
}
/**
 * Get CMS content, populate template values.
 * Any extra parameters passed down are used
 * @param id Content id (required)
 * @param permalink Content permalink (optional)
 */
export declare function populateTemplateContent({ id, permalink }: {
    id?: number;
    permalink?: string;
} & XcapOptionalParameters): Thunk<Promise<PopulateTemplateContent>>;
export interface ListContentResult extends XcapJsonResult {
    contentPaginated: PaginatedCollection<Content>;
    isPage: boolean;
    childCategories: Array<Category>;
}
/**
 * List CMS content by category/permalink.
 * @param permalink Content category permalink (optional)
 * @param p Page number (optional)
 * @param pageSize Page size (optional)
 */
export declare function listContent({ permalink, p, pageSize }: {
    permalink?: string;
    p?: number;
    pageSize?: number;
} & XcapOptionalParameters): Thunk<Promise<ListContentResult>>;
export interface SearchResult extends XcapJsonResult {
    results: PaginatedCollection<Content>;
}
export declare enum ContentSortCritera {
    'CREATED' = "CREATED",
    'MODIFIED' = "MODIFIED",
    'NAME' = "NAME",
    'SORT' = "SORT"
}
/**
 * Search CMS content. Requires stack admin.
 * @param q Search expression
 * @param p Page number (optional)
 * @param pageSize Page size (optional)
 * @param orderBy ContentSortCritera by (optional)
 * @param order: Order (optional)
 */
export declare function search({ q, p, pageSize, orderBy, order }: {
    q?: string;
    p?: number;
    pageSize?: number;
    orderBy?: ContentSortCritera;
    order?: Order;
} & XcapOptionalParameters): Thunk<Promise<SearchResult>>;
export interface Page {
    id: number;
    parentPageId: number;
    name: string;
    permalink: string;
    /** Number of sub pages */
    childCount: number;
    /** Is the page visible? */
    enabled: boolean;
    ogImageUrl: string | null;
    metaDescription: string | null;
    content: Array<PageContent>;
}
export declare enum PageContentType {
    CMS = "stackend-cms"
}
export interface PageContent {
    name: string;
    /** Simple reference type name */
    type: ModuleType;
    /** Is this content visible? */
    visible: boolean;
    /** Reference in string format */
    reference: string;
    /** Referenced object */
    referenceRef: any;
    /** Extra data. Type specific */
    data: string | null;
}
export declare enum MenuVisibility {
    HORIZONTAL = "HORIZONTAL",
    VERTICAL = "VERTICAL",
    FIXED = "FIXED",
    OFF = "OFF"
}
export declare function parseMenuVisibility(v: string): MenuVisibility;
export interface EditContentResult extends XcapJsonResult {
    content: Content | null;
}
/**
 * Edit CMS content.
 * @param id (may be 0 to create a new content object)
 * @param permalink
 * @param headline
 * @param teaser
 * @param body
 * @param categoryId
 *
 * The body may be up to 65KB html.
 *
 * @returns {Promise}
 */
export declare function editContent({ id, permalink, headline, teaser, body, categoryId }: {
    id?: number;
    permalink?: string;
    headline?: string;
    teaser?: string;
    body: string;
    categoryId?: number;
} & XcapOptionalParameters): Thunk<Promise<EditContentResult>>;
/**
 * Set moderation status of cms content
 * @param id
 * @param moderationStatus
 */
export declare function setModerationStatus({ id, moderationStatus }: {
    id: number;
    moderationStatus: ModerationStatus;
} & XcapOptionalParameters): Thunk<Promise<XcapJsonResult>>;
/**
 * Remove CMS content.
 *
 * @param id Cms content id (required)
 * @returns {Promise}
 */
export declare function removeContent({ id }: {
    id: number;
} & XcapOptionalParameters): Thunk<Promise<XcapJsonResult>>;
/**
 * Move CMS content
 * @returns {Thunk<XcapJsonResult>}
 */
export declare function moveContent({ id, newCategoryId, oldCategoryId, insertion, insertionPoint }: {
    id: number;
    newCategoryId: number;
    oldCategoryId?: number;
    insertion: Insertion;
    insertionPoint: number;
} & XcapOptionalParameters): Thunk<Promise<XcapJsonResult>>;
/**
 * Create a new page
 * @param name
 * @param permalink
 */
export declare function newPage(name: string, permalink?: string): Page;
export declare type EditPageResult = XcapJsonResult;
/**
 * Edit a cms page
 *
 * @returns {Thunk<EditPageResult>}
 */
export declare function editPage({ page, parentPageId }: {
    page: Page;
    parentPageId?: number;
} & XcapOptionalParameters): Thunk<Promise<EditPageResult>>;
/**
 * Remove a cms page
 * @param id
 * @returns {Thunk<XcapJsonResult>}
 */
export declare function removePage({ id }: {
    id: number;
} & XcapOptionalParameters): Thunk<Promise<XcapJsonResult>>;
export interface GetPageResult extends XcapJsonResult {
    page: Page | null;
}
/**
 * List all content for a cms page.
 * @param id
 * @param permalink
 * @param p
 * @param pageSize
 * @returns {Thunk<GetPageResult>}
 */
export declare function getPage({ id, permalink, p, pageSize }: {
    id: number;
    permalink?: string;
    p?: number;
    pageSize?: number;
} & XcapOptionalParameters): Thunk<Promise<GetPageResult>>;
/**
 * Search for pages where a content is used.
 * @param contentId
 * @param p
 * @param pageSize
 * @returns {Thunk<SearchPagesResult>}
 */
export declare function searchContentUse({ contentId, p, pageSize }: {
    contentId: number;
    p?: number;
    pageSize?: number;
} & XcapOptionalParameters): Thunk<Promise<SearchPagesResult>>;
export interface SearchPagesResult extends XcapJsonResult {
    result: PaginatedCollection<Page>;
}
/**
 * Search for cms pages
 * @param q
 * @param orderBy "name" or "createdDate"
 * @param order
 * @param p
 * @param pageSize
 * @returns {Thunk<SearchPagesResult>}
 */
export declare function searchPages({ q, p, pageSize, orderBy, order }: {
    q: string;
    p: number | null;
    pageSize: number | null;
    orderBy: 'name' | 'createdDate' | null;
    order: Order | null;
} & XcapOptionalParameters): Thunk<Promise<SearchPagesResult>>;
export interface GetPagesResult extends XcapJsonResult {
    pages: {
        [id: string]: Page;
    };
}
/**
 * Get multiple pages by id.
 * @param pageIds
 * @param permalinks
 * @param communityPermalink
 * @returns {Thunk<GetPagesResult>}
 */
export declare function getPages({ pageIds, permalinks, communityPermalink }: {
    pageIds?: Array<number>;
    permalinks?: Array<string>;
    communityPermalink?: string | null;
} & XcapOptionalParameters): Thunk<Promise<GetPagesResult>>;
export interface SearchPageContentResult extends XcapJsonResult {
    result: {
        [key: string]: Array<PageContent>;
    };
}
/**
 * Search for page content
 * @param q
 * @param codeBinOnly
 * @returns {Thunk<SearchPageContentResult>}
 */
export declare function searchPageContent({ q, codeBinOnly }: {
    q: string;
    codeBinOnly: boolean;
} & XcapOptionalParameters): Thunk<Promise<SearchPageContentResult>>;
export interface GetAvailablePagePermalinkResult extends XcapJsonResult {
    availablePermalink: string;
}
/**
 * Construct an available permalink for cms pages
 * @param pageId
 * @param permalink
 * @returns {Thunk<XcapJsonResult>}
 */
export declare function getAvailablePagePermalink({ pageId, permalink }: {
    pageId?: number | null;
    permalink: string;
} & XcapOptionalParameters): Thunk<Promise<GetAvailablePagePermalinkResult>>;
export declare type SubSiteNode = Node;
export declare type SubSite = Tree;
export interface GetSubSiteResult extends XcapJsonResult {
    tree: SubSite | null;
    referencedObjects: {
        [ref: string]: any;
    };
}
/**
 * Get a subsite by id or permalink
 * @param id
 *
 */
export declare function getSubSite({ id, permalink }: {
    id?: number;
    permalink?: string;
} & XcapOptionalParameters): Thunk<Promise<GetSubSiteResult>>;
/**
 * Store a subsite
 * @param subSite
 */
export declare function storeSubSite({ subSite }: {
    subSite: SubSite;
} & XcapOptionalParameters): Thunk<Promise<GetSubSiteResult>>;
export interface RemoveSubSiteResult extends XcapJsonResult {
    removed: boolean;
}
/**
 * Remove a sub site
 * @param id
 */
export declare function removeSubSite({ id }: {
    id: number;
} & XcapOptionalParameters): Thunk<Promise<RemoveSubSiteResult>>;
export interface SearchSubSiteResult extends XcapJsonResult {
    trees: PaginatedCollection<SubSite>;
}
/**
 * Search for sub sites
 * @param q
 * @param p
 * @param pageSize
 */
export declare function searchSubSites({ q, p, pageSize }: {
    q?: string | null;
    p?: number;
    pageSize?: number;
} & XcapOptionalParameters): Thunk<Promise<SearchSubSiteResult>>;
/**
 * Create, but does not store a new sub site
 */
export declare function newSubSite(name: string): SubSite;
/**
 * Create, but does not store a new sub site node
 */
export declare function newSubSiteNode(name: string): SubSiteNode;
/**
 * Get the default page (start page) id.
 * @param subSite
 * @returns {number}
 */
export declare function getDefaultPageId(subSite: SubSite): number;
/**
 * Add content to the dom. Client side only
 * @param contentId
 * @param html
 * @param css
 * @param javascript
 * @param parent
 */
export declare function _addContentToDom(parent: Element, contentId: number, html: string | null, css: string | null, javascript: string | null): void;
/**
 * Add content to the dom. Client side only
 * @param parent
 * @param content
 */
export declare function addContentToDom(parent: Element, content: Content): void;
/**
 * Remove all child nodes of an element
 * @param element
 */
export declare function removeAllChildNodes(element: Element): void;
/**
 * Construct a composite content value
 * @param html
 * @param css
 * @param js
 */
export declare function createContentValue(html: string, css: string, js: string): string;
/**
 * Split a content object into HTML, CSS and JS.
 * NOTE: Browser only
 * @param content
 * @returns {{htmlValue: (*|string), javascriptValue: (*|string), cssValue: (*|string)}}
 */
export declare function extractContentValues(content: Content | null): {
    htmlValue: string;
    javascriptValue: string;
    cssValue: string;
};
export interface ContentValues {
    [id: string]: {
        html: string | null;
        javascript: string | null;
        style: string | null;
    };
}
//# sourceMappingURL=index.d.ts.map