@ominity/api-typescript 1.1.6 → 1.3.0

package/src/funcs/index.ts

@@ -15,6 +15,7 @@ export * from "./commerce/cartItemsGet.js";
 export * from "./commerce/cartItemsCreate.js";
 export * from "./commerce/cartItemsUpdate.js";
 export * from "./commerce/cartItemsDelete.js";
+export * from "./cms/index.js";
 export * from "./channels/index.js";
 export * from "./localization/index.js";
 export * from "./oauth2/index.js";

package/src/lib/config.ts

@@ -75,7 +75,7 @@ function applyApiVersion(url: URL, apiVersion: string | undefined): URL {
   return url;
 }
 
-export const SDK_VERSION = "1.1.6";
+export const SDK_VERSION = "1.3.0";
 
 export const SDK_METADATA = {
   language: "typescript",

package/src/lib/sdks.ts

@@ -113,6 +113,14 @@ export class ClientSDK {
     }
   }
 
+  setLanguage(language: string | undefined): this {
+    this._options.language = language;
+    this._propagateLanguage(language);
+    return this;
+  }
+
+  protected _propagateLanguage(_language: string | undefined): void {}
+
   public _createRequest(
     context: HookContext,
     conf: RequestConfig,

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

@@ -0,0 +1,31 @@
+/*
+ * CMS Content Entry model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Route, Route$inboundSchema } from "../commerce/route.js";
+
+export type ContentEntry<TFields extends Record<string, any> = Record<string, any>> = {
+    resource: string;
+    id: string;
+    route?: Route | null;
+    updatedAt: string | null;
+    createdAt: string | null;
+    links?: HalLinks;
+} & TFields;
+
+/** @internal */
+export const ContentEntry$inboundSchema: z.ZodType<ContentEntry> = z.object({
+    resource: z.string(),
+    id: z.string(),
+    route: Route$inboundSchema.nullable().optional(),
+    updatedAt: z.string().nullable(),
+    createdAt: z.string().nullable(),
+    _links: HalLinks$inboundSchema.optional(),
+}).passthrough().transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as ContentEntry;
+}) as unknown as z.ZodType<ContentEntry>;

package/src/models/cms/content-type-field.ts

@@ -0,0 +1,54 @@
+/*
+ * CMS Content Type Field model.
+ */
+
+import * as z from "zod/v4";
+
+export type ContentTypeField = {
+    resource: string;
+    id: number;
+    name: string;
+    slug: string;
+    description: string | null;
+    type: string;
+    variant: string | null;
+    required: boolean;
+    translatable: boolean;
+    isRouteParameter: boolean;
+    showInTable: boolean;
+    multiple: boolean;
+    multipleSortable: boolean;
+    min: unknown;
+    max: unknown;
+    defaultValue: unknown;
+    data: unknown;
+    order: number;
+    parentId: number | null;
+    updatedAt: string | null;
+    createdAt: string | null;
+};
+
+/** @internal */
+export const ContentTypeField$inboundSchema: z.ZodType<ContentTypeField> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    name: z.string(),
+    slug: z.string(),
+    description: z.string().nullable(),
+    type: z.string(),
+    variant: z.string().nullable(),
+    required: z.boolean(),
+    translatable: z.boolean(),
+    isRouteParameter: z.boolean(),
+    showInTable: z.boolean(),
+    multiple: z.boolean(),
+    multipleSortable: z.boolean(),
+    min: z.unknown(),
+    max: z.unknown(),
+    defaultValue: z.unknown(),
+    data: z.unknown(),
+    order: z.number(),
+    parentId: z.number().nullable(),
+    updatedAt: z.string().nullable(),
+    createdAt: z.string().nullable(),
+});

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

@@ -0,0 +1,75 @@
+/*
+ * CMS Content Type model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import {
+    ContentTypeField,
+    ContentTypeField$inboundSchema,
+} from "./content-type-field.js";
+
+export type ContentTypeRouteConfiguration = {
+    name: string;
+    parameterFieldSlugs: Array<string>;
+};
+
+export type ContentType = {
+    resource: string;
+    id: number;
+    name: string;
+    slug: string;
+    resourceKey: string | null;
+    singularTitle: string | null;
+    pluralTitle: string | null;
+    description: string | null;
+    translatable: boolean;
+    routable: boolean;
+    route: ContentTypeRouteConfiguration | null;
+    showInNavigation: boolean;
+    navigationGroup: string | null;
+    formLayout: Record<string, any> | Array<any> | null;
+    fields?: Array<ContentTypeField>;
+    updatedAt: string | null;
+    createdAt: string | null;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const ContentTypeRouteConfiguration$inboundSchema: z.ZodType<
+    ContentTypeRouteConfiguration
+> = z.object({
+    name: z.string(),
+    parameterFieldSlugs: z.array(z.string()),
+});
+
+/** @internal */
+export const ContentType$inboundSchema: z.ZodType<ContentType> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    name: z.string(),
+    slug: z.string(),
+    resourceKey: z.string().nullable(),
+    singularTitle: z.string().nullable(),
+    pluralTitle: z.string().nullable(),
+    description: z.string().nullable(),
+    translatable: z.boolean(),
+    routable: z.boolean(),
+    route: ContentTypeRouteConfiguration$inboundSchema.nullable(),
+    showInNavigation: z.boolean(),
+    navigationGroup: z.string().nullable(),
+    formLayout: z.union([
+        z.record(z.string(), z.any()),
+        z.array(z.any()),
+        z.null(),
+    ]),
+    fields: z.array(ContentTypeField$inboundSchema).optional(),
+    updatedAt: z.string().nullable(),
+    createdAt: z.string().nullable(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as ContentType;
+});

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;
+    filter?: Record<string, any> | 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(),
+    filter: z.record(z.string(), z.any()).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/channels/index.ts

@@ -57,4 +57,9 @@ export class Channels extends ClientSDK {
       options,
     ));
   }
+
+  protected override _propagateLanguage(language: string | undefined): void {
+    this._types?.setLanguage(language);
+    this._domains?.setLanguage(language);
+  }
 }

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));
     }
@@ -34,4 +48,13 @@ export class Cms extends ClientSDK {
     get menus(): Menus {
         return (this._menus ??= new Menus(this._options));
     }
+
+    protected override _propagateLanguage(language: string | undefined): void {
+        this._components?.setLanguage(language);
+        this._content?.setLanguage(language);
+        this._contentTypes?.setLanguage(language);
+        this._layouts?.setLanguage(language);
+        this._pages?.setLanguage(language);
+        this._menus?.setLanguage(language);
+    }
 }

package/src/sdk/commerce/index.ts

@@ -104,4 +104,21 @@ export class Commerce extends ClientSDK {
   get currencies(): Currencies {
     return (this._currencies ??= new Currencies(this._options));
   }
+
+  protected override _propagateLanguage(language: string | undefined): void {
+    this._cartItems?.setLanguage(language);
+    this._carts?.setLanguage(language);
+    this._categories?.setLanguage(language);
+    this._products?.setLanguage(language);
+    this._invoices?.setLanguage(language);
+    this._productGroups?.setLanguage(language);
+    this._subscriptionIntervals?.setLanguage(language);
+    this._orders?.setLanguage(language);
+    this._payments?.setLanguage(language);
+    this._vatValidations?.setLanguage(language);
+    this._shippingMethods?.setLanguage(language);
+    this._shippingZones?.setLanguage(language);
+    this._reviews?.setLanguage(language);
+    this._currencies?.setLanguage(language);
+  }
 }

package/src/sdk/localization/index.ts

@@ -17,5 +17,9 @@ export class Localization extends ClientSDK {
   get locales(): LocalizationLocales {
     return (this._locales ??= new LocalizationLocales(this._options));
   }
-}
 
+  protected override _propagateLanguage(language: string | undefined): void {
+    this._languages?.setLanguage(language);
+    this._locales?.setLanguage(language);
+  }
+}

package/src/sdk/sdk.ts

@@ -96,4 +96,17 @@ export class Ominity extends ClientSDK {
   get admins(): Admins {
     return (this._admins ??= new Admins(this._options));
   }
+
+  protected override _propagateLanguage(language: string | undefined): void {
+    this._commerce?.setLanguage(language);
+    this._cms?.setLanguage(language);
+    this._channels?.setLanguage(language);
+    this._settings?.setLanguage(language);
+    this._http?.setLanguage(language);
+    this._localization?.setLanguage(language);
+    this._oauth2?.setLanguage(language);
+    this._me?.setLanguage(language);
+    this._users?.setLanguage(language);
+    this._admins?.setLanguage(language);
+  }
 }

package/src/sdk/settings/index.ts

@@ -27,4 +27,10 @@ export class Settings extends ClientSDK {
     get paymentMethods(): PaymentMethods {
         return (this._paymentMethods ??= new PaymentMethods(this._options));
     }
+
+    protected override _propagateLanguage(language: string | undefined): void {
+        this._countries?.setLanguage(language);
+        this._socialProviders?.setLanguage(language);
+        this._paymentMethods?.setLanguage(language);
+    }
 }

package/src/sdk/users/index.ts

@@ -121,4 +121,12 @@ export class Users extends ClientSDK {
       options,
     ));
   }
+
+  protected override _propagateLanguage(language: string | undefined): void {
+    this._logins?.setLanguage(language);
+    this._customers?.setLanguage(language);
+    this._oauthAccounts?.setLanguage(language);
+    this._mfaMethods?.setLanguage(language);
+    this._recoveryCodes?.setLanguage(language);
+  }
 }