@conradsix/c4m-client 0.0.0-stage → 0.1.0-preview.1

package/dist/index.js

@@ -0,0 +1,690 @@
+/* eslint-disable */
+/* tslint:disable */
+// @ts-nocheck
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+export var ListPagesStatus;
+(function (ListPagesStatus) {
+    ListPagesStatus[ListPagesStatus["NotArchived"] = 0] = "NotArchived";
+    ListPagesStatus[ListPagesStatus["Published"] = 1] = "Published";
+    ListPagesStatus[ListPagesStatus["Unpublished"] = 2] = "Unpublished";
+    ListPagesStatus[ListPagesStatus["Archived"] = 3] = "Archived";
+    ListPagesStatus[ListPagesStatus["All"] = 4] = "All";
+})(ListPagesStatus || (ListPagesStatus = {}));
+export var ListPagesStringFilterType;
+(function (ListPagesStringFilterType) {
+    ListPagesStringFilterType[ListPagesStringFilterType["Contains"] = 0] = "Contains";
+    ListPagesStringFilterType[ListPagesStringFilterType["StartsWith"] = 1] = "StartsWith";
+    ListPagesStringFilterType[ListPagesStringFilterType["EndsWith"] = 2] = "EndsWith";
+    ListPagesStringFilterType[ListPagesStringFilterType["Regex"] = 3] = "Regex";
+})(ListPagesStringFilterType || (ListPagesStringFilterType = {}));
+export var ListPagesSort;
+(function (ListPagesSort) {
+    ListPagesSort[ListPagesSort["SlugAsc"] = 0] = "SlugAsc";
+    ListPagesSort[ListPagesSort["SlugDesc"] = 1] = "SlugDesc";
+    ListPagesSort[ListPagesSort["PathAsc"] = 2] = "PathAsc";
+    ListPagesSort[ListPagesSort["PathDesc"] = 3] = "PathDesc";
+    ListPagesSort[ListPagesSort["CreatedAtAsc"] = 4] = "CreatedAtAsc";
+    ListPagesSort[ListPagesSort["CreatedAtDesc"] = 5] = "CreatedAtDesc";
+    ListPagesSort[ListPagesSort["UpdatedAtAsc"] = 6] = "UpdatedAtAsc";
+    ListPagesSort[ListPagesSort["UpdatedAtDesc"] = 7] = "UpdatedAtDesc";
+    ListPagesSort[ListPagesSort["SeoTitleAsc"] = 8] = "SeoTitleAsc";
+    ListPagesSort[ListPagesSort["SeoTitleDesc"] = 9] = "SeoTitleDesc";
+    ListPagesSort[ListPagesSort["PublishedAsc"] = 10] = "PublishedAsc";
+    ListPagesSort[ListPagesSort["PublishedDesc"] = 11] = "PublishedDesc";
+    ListPagesSort[ListPagesSort["StatusAsc"] = 12] = "StatusAsc";
+    ListPagesSort[ListPagesSort["StatusDesc"] = 13] = "StatusDesc";
+    ListPagesSort[ListPagesSort["LinksInAsc"] = 14] = "LinksInAsc";
+    ListPagesSort[ListPagesSort["LinksInDesc"] = 15] = "LinksInDesc";
+})(ListPagesSort || (ListPagesSort = {}));
+export var PagePathAvailability;
+(function (PagePathAvailability) {
+    PagePathAvailability[PagePathAvailability["Available"] = 0] = "Available";
+    PagePathAvailability[PagePathAvailability["Taken"] = 1] = "Taken";
+    PagePathAvailability[PagePathAvailability["Restricted"] = 2] = "Restricted";
+    PagePathAvailability[PagePathAvailability["ParentNotFound"] = 3] = "ParentNotFound";
+    PagePathAvailability[PagePathAvailability["CircularParent"] = 4] = "CircularParent";
+})(PagePathAvailability || (PagePathAvailability = {}));
+export var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["JsonApi"] = "application/vnd.api+json";
+    ContentType["FormData"] = "multipart/form-data";
+    ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+    ContentType["Text"] = "text/plain";
+})(ContentType || (ContentType = {}));
+export class HttpClient {
+    baseUrl = "";
+    securityData = null;
+    securityWorker;
+    abortControllers = new Map();
+    customFetch = (...fetchParams) => fetch(...fetchParams);
+    baseApiParams = {
+        credentials: "same-origin",
+        headers: {},
+        redirect: "follow",
+        referrerPolicy: "no-referrer",
+    };
+    constructor(apiConfig = {}) {
+        Object.assign(this, apiConfig);
+    }
+    setSecurityData = (data) => {
+        this.securityData = data;
+    };
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+    }
+    toQueryString(rawQuery) {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
+        return keys
+            .map((key) => Array.isArray(query[key])
+            ? this.addArrayQueryParam(query, key)
+            : this.addQueryParam(query, key))
+            .join("&");
+    }
+    addQueryParams(rawQuery) {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : "";
+    }
+    contentFormatters = {
+        [ContentType.Json]: (input) => input !== null && (typeof input === "object" || typeof input === "string")
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.JsonApi]: (input) => input !== null && (typeof input === "object" || typeof input === "string")
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.Text]: (input) => input !== null && typeof input !== "string"
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.FormData]: (input) => Object.keys(input || {}).reduce((formData, key) => {
+            const property = input[key];
+            formData.append(key, property instanceof Blob
+                ? property
+                : typeof property === "object" && property !== null
+                    ? JSON.stringify(property)
+                    : `${property}`);
+            return formData;
+        }, new FormData()),
+        [ContentType.UrlEncoded]: (input) => this.toQueryString(input),
+    };
+    mergeRequestParams(params1, params2) {
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(this.baseApiParams.headers || {}),
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {}),
+            },
+        };
+    }
+    createAbortSignal = (cancelToken) => {
+        if (this.abortControllers.has(cancelToken)) {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                return abortController.signal;
+            }
+            return void 0;
+        }
+        const abortController = new AbortController();
+        this.abortControllers.set(cancelToken, abortController);
+        return abortController.signal;
+    };
+    abortRequest = (cancelToken) => {
+        const abortController = this.abortControllers.get(cancelToken);
+        if (abortController) {
+            abortController.abort();
+            this.abortControllers.delete(cancelToken);
+        }
+    };
+    request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+        const secureParams = ((typeof secure === "boolean" ? secure : this.baseApiParams.secure) &&
+            this.securityWorker &&
+            (await this.securityWorker(this.securityData))) ||
+            {};
+        const requestParams = this.mergeRequestParams(params, secureParams);
+        const queryString = query && this.toQueryString(query);
+        const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+        const responseFormat = format || requestParams.format;
+        return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+            ...requestParams,
+            headers: {
+                ...(requestParams.headers || {}),
+                ...(type && type !== ContentType.FormData
+                    ? { "Content-Type": type }
+                    : {}),
+            },
+            signal: (cancelToken
+                ? this.createAbortSignal(cancelToken)
+                : requestParams.signal) || null,
+            body: typeof body === "undefined" || body === null
+                ? null
+                : payloadFormatter(body),
+        }).then(async (response) => {
+            const r = response.clone();
+            r.data = null;
+            r.error = null;
+            const data = !responseFormat
+                ? r
+                : await response[responseFormat]()
+                    .then((data) => {
+                    if (r.ok) {
+                        r.data = data;
+                    }
+                    else {
+                        r.error = data;
+                    }
+                    return r;
+                })
+                    .catch((e) => {
+                    r.error = e;
+                    return r;
+                });
+            if (cancelToken) {
+                this.abortControllers.delete(cancelToken);
+            }
+            if (!response.ok)
+                throw data;
+            return data;
+        });
+    };
+}
+/**
+ * @title C4M
+ * @version v1
+ *
+ * The C4M engine's endpoints: pages and their versions, block and menu action types, and menus.
+ */
+export class Api extends HttpClient {
+    pages = {
+        /**
+         * No description
+         *
+         * @tags Pages
+         * @name ArchivePage
+         * @summary Archives an unpublished page with no unarchived children, retaining its content and history.
+         * @request POST:/pages/{id}/archive
+         */
+        archivePage: (id, params = {}) => this.request({
+            path: `/pages/${id}/archive`,
+            method: "POST",
+            ...params,
+        }),
+        /**
+         * @description Creates a new page with the specified content blocks, optionally leaving its initial version as a draft.
+         *
+         * @tags Pages
+         * @name CreatePage
+         * @summary Creates a new page.
+         * @request POST:/pages
+         */
+        createPage: (data, params = {}) => this.request({
+            path: `/pages`,
+            method: "POST",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a paginated list of pages with support for sorting, searching by SEO title or path, and filtering by slug, path, and creation/update dates.
+         *
+         * @tags Pages
+         * @name ListPages
+         * @summary Lists pages with pagination, sorting, and filtering.
+         * @request GET:/pages
+         */
+        listPages: (query, params = {}) => this.request({
+            path: `/pages`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a specific page by its unique identifier including all related blocks. Optionally specify a version ID to get a specific version, otherwise returns the current version.
+         *
+         * @tags Pages
+         * @name GetPage
+         * @summary Gets a page by ID.
+         * @request GET:/pages/{id}
+         */
+        getPage: (id, query, params = {}) => this.request({
+            path: `/pages/${id}`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * No description
+         *
+         * @tags Pages
+         * @name UpdatePage
+         * @summary Creates a content and SEO draft without changing page details or publication.
+         * @request PUT:/pages/{id}
+         */
+        updatePage: (id, data, params = {}) => this.request({
+            path: `/pages/${id}`,
+            method: "PUT",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a specific page by path including all related blocks. Returns the current version of the page.
+         *
+         * @tags Pages
+         * @name GetPageByPath
+         * @summary Gets a page by path.
+         * @request GET:/pages/by-path
+         */
+        getPageByPath: (query, params = {}) => this.request({
+            path: `/pages/by-path`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a specific page by its version identifier including all related blocks.
+         *
+         * @tags Pages
+         * @name GetPageByVersion
+         * @summary Gets a page by version.
+         * @request GET:/pages/by-version/{id}
+         */
+        getPageByVersion: (id, query, params = {}) => this.request({
+            path: `/pages/by-version/${id}`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Sets the specified page version as the current version and unsets the previous current version.
+         *
+         * @tags Pages
+         * @name UpdateCurrentPageVersion
+         * @summary Sets a page version as current.
+         * @request PUT:/pages/by-version/{id}
+         */
+        updateCurrentPageVersion: (id, data, params = {}) => this.request({
+            path: `/pages/by-version/${id}`,
+            method: "PUT",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves the complete version history for a specific page, including high-level change summaries.
+         *
+         * @tags Pages
+         * @name GetPageHistory
+         * @summary Gets page version history by page ID.
+         * @request GET:/pages/{id}/history
+         */
+        getPageHistory: (id, query, params = {}) => this.request({
+            path: `/pages/${id}/history`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves just the path of a specific page by its unique identifier. This is a performance-optimized endpoint that returns only the path without loading the full page data.
+         *
+         * @tags Pages
+         * @name GetPagePath
+         * @summary Gets a page path by ID.
+         * @request GET:/pages/{id}/path
+         */
+        getPagePath: (id, params = {}) => this.request({
+            path: `/pages/${id}/path`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Resolves the path a page would have with the given parent and slug, and reports whether that path can be used. Pass the ID of a page being edited to exclude it from the check.
+         *
+         * @tags Pages
+         * @name GetPagePathAvailability
+         * @summary Checks whether a page path is available.
+         * @request GET:/pages/path-availability
+         */
+        getPagePathAvailability: (query, params = {}) => this.request({
+            path: `/pages/path-availability`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * No description
+         *
+         * @tags Pages
+         * @name PublishPage
+         * @summary Publishes the saved Current version of a page.
+         * @request POST:/pages/{id}/publish
+         */
+        publishPage: (id, data, params = {}) => this.request({
+            path: `/pages/${id}/publish`,
+            method: "POST",
+            body: data,
+            type: ContentType.Json,
+            ...params,
+        }),
+        /**
+         * No description
+         *
+         * @tags Pages
+         * @name ReparentPageChildren
+         * @summary Moves all unarchived direct children and their subtrees to another parent or the top level.
+         * @request POST:/pages/{id}/reparent-children
+         */
+        reparentPageChildren: (id, data, params = {}) => this.request({
+            path: `/pages/${id}/reparent-children`,
+            method: "POST",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * No description
+         *
+         * @tags Pages
+         * @name UnpublishPage
+         * @summary Unpublishes a page unless published pages or menus reference it.
+         * @request POST:/pages/{id}/unpublish
+         */
+        unpublishPage: (id, data, params = {}) => this.request({
+            path: `/pages/${id}/unpublish`,
+            method: "POST",
+            body: data,
+            type: ContentType.Json,
+            ...params,
+        }),
+        /**
+         * No description
+         *
+         * @tags Pages
+         * @name UpdatePageDetails
+         * @summary Updates unversioned page details without creating a content version.
+         * @request PUT:/pages/{id}/details
+         */
+        updatePageDetails: (id, data, params = {}) => this.request({
+            path: `/pages/${id}/details`,
+            method: "PUT",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+    };
+    navigationSettings = {
+        /**
+         * @description Retrieves the default navigation and footer menu selections.
+         *
+         * @tags Navigation-Settings
+         * @name GetNavigationSettings
+         * @summary Gets navigation settings.
+         * @request GET:/navigation-settings
+         */
+        getNavigationSettings: (params = {}) => this.request({
+            path: `/navigation-settings`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Changes the default navigation and footer menus immediately.
+         *
+         * @tags Navigation-Settings
+         * @name UpdateNavigationSettings
+         * @summary Updates navigation settings.
+         * @request PUT:/navigation-settings
+         */
+        updateNavigationSettings: (data, params = {}) => this.request({
+            path: `/navigation-settings`,
+            method: "PUT",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+    };
+    menuActionTypes = {
+        /**
+         * @description Adds a new menu action type to the system.
+         *
+         * @tags Menu-Action-Types
+         * @name CreateMenuActionType
+         * @summary Creates a new menu action type.
+         * @request POST:/menu-action-types
+         */
+        createMenuActionType: (data, params = {}) => this.request({
+            path: `/menu-action-types`,
+            method: "POST",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves all available menu action types with their schemas.
+         *
+         * @tags Menu-Action-Types
+         * @name ListMenuActionTypes
+         * @summary Lists all menu action types.
+         * @request GET:/menu-action-types
+         */
+        listMenuActionTypes: (params = {}) => this.request({
+            path: `/menu-action-types`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a menu action type including its JSON schema for validation.
+         *
+         * @tags Menu-Action-Types
+         * @name GetMenuActionType
+         * @summary Gets a menu action type by ID.
+         * @request GET:/menu-action-types/{id}
+         */
+        getMenuActionType: (id, params = {}) => this.request({
+            path: `/menu-action-types/${id}`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a specific menu action type from the system by its name. If version is not specified, returns the latest version.
+         *
+         * @tags Menu-Action-Types
+         * @name GetMenuActionTypeByName
+         * @summary Gets a menu action type by name.
+         * @request GET:/menu-action-types/by-name/{name}
+         */
+        getMenuActionTypeByName: (name, query, params = {}) => this.request({
+            path: `/menu-action-types/by-name/${name}`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+    };
+    menus = {
+        /**
+         * @description Adds a new menu with optional menu items to the system.
+         *
+         * @tags Menus
+         * @name CreateMenu
+         * @summary Creates a new menu.
+         * @request POST:/menus
+         */
+        createMenu: (data, params = {}) => this.request({
+            path: `/menus`,
+            method: "POST",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a paginated list of menus.
+         *
+         * @tags Menus
+         * @name ListMenus
+         * @summary Lists menus.
+         * @request GET:/menus
+         */
+        listMenus: (query, params = {}) => this.request({
+            path: `/menus`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves the menu configured as the site-wide navigation fallback.
+         *
+         * @tags Menus
+         * @name GetDefaultMenu
+         * @summary Gets the default navigation menu.
+         * @request GET:/menus/default
+         */
+        getDefaultMenu: (params = {}) => this.request({
+            path: `/menus/default`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves the menu configured for the site-wide footer.
+         *
+         * @tags Menus
+         * @name GetFooterMenu
+         * @summary Gets the footer menu.
+         * @request GET:/menus/footer
+         */
+        getFooterMenu: (params = {}) => this.request({
+            path: `/menus/footer`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a menu with its hierarchical structure of menu items.
+         *
+         * @tags Menus
+         * @name GetMenu
+         * @summary Gets a menu by ID.
+         * @request GET:/menus/{id}
+         */
+        getMenu: (id, params = {}) => this.request({
+            path: `/menus/${id}`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Replaces all menu items with the provided tree structure.
+         *
+         * @tags Menus
+         * @name UpdateMenu
+         * @summary Updates an existing menu.
+         * @request PUT:/menus/{menuId}
+         */
+        updateMenu: (menuId, data, params = {}) => this.request({
+            path: `/menus/${menuId}`,
+            method: "PUT",
+            body: data,
+            type: ContentType.Json,
+            ...params,
+        }),
+    };
+    blockTypes = {
+        /**
+         * @description Adds a new block type to the system.
+         *
+         * @tags Block-Types
+         * @name CreateBlockType
+         * @summary Creates a new block type.
+         * @request POST:/block-types
+         */
+        createBlockType: (data, params = {}) => this.request({
+            path: `/block-types`,
+            method: "POST",
+            body: data,
+            type: ContentType.Json,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a paginated list of block types grouped by name. All versions of each block type are included together.
+         *
+         * @tags Block-Types
+         * @name ListBlockTypes
+         * @summary Lists block types with pagination.
+         * @request GET:/block-types
+         */
+        listBlockTypes: (query, params = {}) => this.request({
+            path: `/block-types`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a specific block type from the system.
+         *
+         * @tags Block-Types
+         * @name GetBlockType
+         * @summary Gets a block type by ID.
+         * @request GET:/block-types/{id}
+         */
+        getBlockType: (id, params = {}) => this.request({
+            path: `/block-types/${id}`,
+            method: "GET",
+            format: "json",
+            ...params,
+        }),
+        /**
+         * @description Retrieves a specific block type from the system by its name. If version is not specified, returns the latest version.
+         *
+         * @tags Block-Types
+         * @name GetBlockTypeByName
+         * @summary Gets a block type by name.
+         * @request GET:/block-types/by-name/{name}
+         */
+        getBlockTypeByName: (name, query, params = {}) => this.request({
+            path: `/block-types/by-name/${name}`,
+            method: "GET",
+            query: query,
+            format: "json",
+            ...params,
+        }),
+    };
+}
+//# sourceMappingURL=index.js.map