@ominity/api-typescript 1.1.6 → 1.2.0

package/src/models/cms/index.ts

@@ -3,6 +3,6 @@ export * from "./layout.js";
 export * from "./page.js";
 export * from "./menu.js";
 export * from "./page-component.js";
-
-
-
+export * from "./content-type-field.js";
+export * from "./content-type.js";
+export * from "./content-entry.js";

package/src/models/commerce/route.ts

@@ -4,12 +4,12 @@
 
 import * as z from "zod/v4";
 
-export type RouteParameters = Record<string, string | number>;
+export type RouteParameters = Record<string, string | number | boolean | null>;
 
 export type Route = {
   resource: string;
   name: string;
-  locale: string;
+  locale: string | null;
   parameters: RouteParameters;
 };
 
@@ -17,13 +17,13 @@ export type Route = {
 export const RouteParameters$inboundSchema: z.ZodType<RouteParameters> = z
   .record(
     z.string(),
-    z.union([z.string(), z.number()]),
+    z.union([z.string(), z.number(), z.boolean(), z.null()]),
   );
 
 /** @internal */
 export const Route$inboundSchema: z.ZodType<Route> = z.object({
   resource: z.string(),
   name: z.string(),
-  locale: z.string(),
+  locale: z.string().nullable(),
   parameters: RouteParameters$inboundSchema,
 });

package/src/models/index.ts

@@ -1,5 +1,6 @@
 export * from "./security.js";
 export * from "./channels/index.js";
+export * from "./cms/index.js";
 export * from "./common/index.js";
 export * from "./commerce/index.js";
 export * from "./localization/index.js";

package/src/models/operations/cms-content-types.ts

@@ -0,0 +1,74 @@
+/*
+ * CMS Content Types operations.
+ */
+
+import * as z from "zod/v4";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { ContentType, ContentType$inboundSchema } from "../cms/content-type.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+
+export type ListContentTypesRequest = {
+    filterId?: number | undefined;
+    filterNameSingular?: string | undefined;
+    filterNamePlural?: string | undefined;
+    filterSlug?: string | undefined;
+    filterResourceKey?: string | undefined;
+    include?: string | undefined;
+    sort?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+};
+
+export type ListContentTypesResponse = Paginated<ContentType>;
+
+/** @internal */
+export const ListContentTypesRequest$outboundSchema: z.ZodType<
+    ListContentTypesRequest
+> = z.object({
+    filterId: z.number().optional(),
+    filterNameSingular: z.string().optional(),
+    filterNamePlural: z.string().optional(),
+    filterSlug: z.string().optional(),
+    filterResourceKey: z.string().optional(),
+    include: z.string().optional(),
+    sort: z.string().optional(),
+    page: z.number().optional(),
+    limit: z.number().optional(),
+});
+
+/** @internal */
+export const ListContentTypesResponse$inboundSchema: z.ZodType<
+    ListContentTypesResponse
+> = z.object({
+    _embedded: z.object({
+        content_types: z.array(ContentType$inboundSchema),
+    }),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+    buildPaginated(
+        v._embedded.content_types,
+        v.count,
+        v._links,
+    )
+);
+
+export type GetContentTypeRequest = {
+    id: number;
+    include?: string | undefined;
+};
+
+export type GetContentTypeResponse = ContentType;
+
+/** @internal */
+export const GetContentTypeRequest$outboundSchema: z.ZodType<
+    GetContentTypeRequest
+> = z.object({
+    id: z.number(),
+    include: z.string().optional(),
+});
+
+/** @internal */
+export const GetContentTypeResponse$inboundSchema: z.ZodType<
+    GetContentTypeResponse
+> = ContentType$inboundSchema;

package/src/models/operations/cms-content.ts

@@ -0,0 +1,132 @@
+/*
+ * CMS Content operations.
+ */
+
+import * as z from "zod/v4";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { ContentEntry, ContentEntry$inboundSchema } from "../cms/content-entry.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+
+export type ListContentRequest = {
+    slug: string;
+    filterId?: string | undefined;
+    sort?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+};
+
+export type ListContentResponse<TEntry extends ContentEntry = ContentEntry> = Paginated<TEntry>;
+
+/** @internal */
+export const ListContentRequest$outboundSchema: z.ZodType<
+    ListContentRequest
+> = z.object({
+    slug: z.string(),
+    filterId: z.string().optional(),
+    sort: z.string().optional(),
+    page: z.number().optional(),
+    limit: z.number().optional(),
+});
+
+/** @internal */
+export const ListContentResponse$inboundSchema: z.ZodType<
+    ListContentResponse
+> = z.object({
+    _embedded: z.record(z.string(), z.array(ContentEntry$inboundSchema)),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    const entries = Object.values(v._embedded)[0] ?? [];
+
+    return buildPaginated(
+        entries,
+        v.count,
+        v._links,
+    );
+});
+
+export type GetContentRequest = {
+    slug: string;
+    id: string;
+};
+
+export type GetContentResponse<TEntry extends ContentEntry = ContentEntry> = TEntry;
+
+/** @internal */
+export const GetContentRequest$outboundSchema: z.ZodType<
+    GetContentRequest
+> = z.object({
+    slug: z.string(),
+    id: z.string(),
+});
+
+/** @internal */
+export const GetContentResponse$inboundSchema: z.ZodType<
+    GetContentResponse
+> = ContentEntry$inboundSchema;
+
+export type CreateContentRequest = {
+    slug: string;
+    data: Record<string, any>;
+};
+
+export type CreateContentResponse<TEntry extends ContentEntry = ContentEntry> = TEntry;
+
+/** @internal */
+export const CreateContentRequest$outboundSchema: z.ZodType<
+    CreateContentRequest
+> = z.object({
+    slug: z.string(),
+    data: z.record(z.string(), z.any()),
+});
+
+/** @internal */
+export const CreateContentResponse$inboundSchema: z.ZodType<
+    CreateContentResponse
+> = ContentEntry$inboundSchema;
+
+export type UpdateContentRequest = {
+    slug: string;
+    id: string;
+    data: Record<string, any>;
+};
+
+export type UpdateContentResponse<TEntry extends ContentEntry = ContentEntry> = TEntry;
+
+/** @internal */
+export const UpdateContentRequest$outboundSchema: z.ZodType<
+    UpdateContentRequest
+> = z.object({
+    slug: z.string(),
+    id: z.string(),
+    data: z.record(z.string(), z.any()),
+});
+
+/** @internal */
+export const UpdateContentResponse$inboundSchema: z.ZodType<
+    UpdateContentResponse
+> = ContentEntry$inboundSchema;
+
+export type DeleteContentRequest = {
+    slug: string;
+    id: string;
+};
+
+export type DeleteContentResponse = {
+    deleted: boolean;
+};
+
+/** @internal */
+export const DeleteContentRequest$outboundSchema: z.ZodType<
+    DeleteContentRequest
+> = z.object({
+    slug: z.string(),
+    id: z.string(),
+});
+
+/** @internal */
+export const DeleteContentResponse$inboundSchema: z.ZodType<
+    DeleteContentResponse
+> = z.object({
+    deleted: z.boolean(),
+});

package/src/models/operations/index.ts

@@ -2,7 +2,9 @@ export * from "./commerce-products.js";
 export * from "./commerce-categories.js";
 export * from "./commerce-carts.js";
 export * from "./commerce-cart-items.js";
+export * from "./cms-content.js";
 export * from "./cms-components.js";
+export * from "./cms-content-types.js";
 export * from "./cms-layouts.js";
 export * from "./cms-pages.js";
 export * from "./cms-menus.js";

package/src/sdk/cms/content-types.ts

@@ -0,0 +1,25 @@
+/*
+ * CMS Content Types SDK.
+ */
+
+import { contentTypesList } from "../../funcs/cms/contentTypesList.js";
+import { contentTypesGet } from "../../funcs/cms/contentTypesGet.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export class ContentTypes extends ClientSDK {
+    async list(
+        request?: operations.ListContentTypesRequest | undefined,
+        options?: RequestOptions,
+    ): Promise<operations.ListContentTypesResponse> {
+        return unwrapAsync(contentTypesList(this, request, options));
+    }
+
+    async get(
+        request: operations.GetContentTypeRequest,
+        options?: RequestOptions,
+    ): Promise<operations.GetContentTypeResponse> {
+        return unwrapAsync(contentTypesGet(this, request, options));
+    }
+}

package/src/sdk/cms/content.ts

@@ -0,0 +1,50 @@
+/*
+ * CMS Content SDK.
+ */
+
+import { contentList } from "../../funcs/cms/contentList.js";
+import { contentGet } from "../../funcs/cms/contentGet.js";
+import { contentCreate } from "../../funcs/cms/contentCreate.js";
+import { contentUpdate } from "../../funcs/cms/contentUpdate.js";
+import { contentDelete } from "../../funcs/cms/contentDelete.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { ContentEntry } from "../../models/cms/content-entry.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export class Content extends ClientSDK {
+    async list<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.ListContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.ListContentResponse<TEntry>> {
+        return unwrapAsync(contentList<TEntry>(this, request, options));
+    }
+
+    async get<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.GetContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.GetContentResponse<TEntry>> {
+        return unwrapAsync(contentGet<TEntry>(this, request, options));
+    }
+
+    async create<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.CreateContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.CreateContentResponse<TEntry>> {
+        return unwrapAsync(contentCreate<TEntry>(this, request, options));
+    }
+
+    async update<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.UpdateContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.UpdateContentResponse<TEntry>> {
+        return unwrapAsync(contentUpdate<TEntry>(this, request, options));
+    }
+
+    async delete(
+        request: operations.DeleteContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.DeleteContentResponse> {
+        return unwrapAsync(contentDelete(this, request, options));
+    }
+}

package/src/sdk/cms/index.ts

@@ -4,17 +4,23 @@
 
 import { ClientSDK } from "../../lib/sdks.js";
 import { Components } from "./components.js";
+import { Content } from "./content.js";
+import { ContentTypes } from "./content-types.js";
 import { Layouts } from "./layouts.js";
 import { Pages } from "./pages.js";
 import { Menus } from "./menus.js";
 
 export { Components } from "./components.js";
+export { Content } from "./content.js";
+export { ContentTypes } from "./content-types.js";
 export { Layouts } from "./layouts.js";
 export { Pages } from "./pages.js";
 export { Menus } from "./menus.js";
 
 export class Cms extends ClientSDK {
     private _components?: Components;
+    private _content?: Content;
+    private _contentTypes?: ContentTypes;
     private _layouts?: Layouts;
     private _pages?: Pages;
     private _menus?: Menus;
@@ -23,6 +29,14 @@ export class Cms extends ClientSDK {
         return (this._components ??= new Components(this._options));
     }
 
+    get content(): Content {
+        return (this._content ??= new Content(this._options));
+    }
+
+    get contentTypes(): ContentTypes {
+        return (this._contentTypes ??= new ContentTypes(this._options));
+    }
+
     get layouts(): Layouts {
         return (this._layouts ??= new Layouts(this._options));
     }