@ominity/api-typescript 0.0.3 → 1.1.0

package/src/models/commerce/vat-validation.ts

@@ -0,0 +1,30 @@
+/*
+ * Commerce VAT Validation model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type VatValidation = {
+    resource: string;
+    vatNumber: string;
+    isValid: boolean;
+    updatedAt: string;
+    createdAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const VatValidation$inboundSchema: z.ZodType<VatValidation> = z.object({
+    resource: z.string(),
+    vatNumber: z.string(),
+    isValid: z.boolean(),
+    updatedAt: z.string(),
+    createdAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as VatValidation;
+});

package/src/models/common/amount.ts

@@ -1,16 +1,25 @@
 /*
- * Currency amount model (string value + currency code).
+ * Commerce Amount model.
  */
 
 import * as z from "zod/v4";
 
 export type CurrencyAmount = {
-  value: string;
+  value?: string | undefined;
+  amount?: string | undefined;
   currency: string;
 };
 
 /** @internal */
 export const CurrencyAmount$inboundSchema: z.ZodType<CurrencyAmount> = z.object({
-  value: z.string(),
+  value: z.string().optional(),
+  amount: z.string().optional(),
+  currency: z.string(),
+});
+
+/** @internal */
+export const CurrencyAmount$outboundSchema: z.ZodType<CurrencyAmount> = z.object({
+  value: z.string().optional(),
+  amount: z.string().optional(),
   currency: z.string(),
 });

package/src/models/identity/admin.ts

@@ -0,0 +1,32 @@
+/*
+ * Admin model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type Admin = {
+  resource: "admin";
+  id: number;
+  name?: string;
+  email?: string;
+  avatar?: string | null;
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const Admin$inboundSchema: z.ZodType<Admin> = z.object({
+  resource: z.literal("admin"),
+  id: z.number().int(),
+  name: z.string().optional(),
+  email: z.string().optional(),
+  avatar: z.string().nullable().optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+})
+  .loose()
+  .transform((v) => remap$(v, { _links: "links" }) as Admin);

package/src/models/identity/api-key.ts

@@ -0,0 +1,32 @@
+/*
+ * API key model.
+ *
+ * Note: fields are intentionally optional until a concrete schema is provided.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type ApiKey = {
+  resource: "api_key";
+  id?: number | string;
+  description?: string;
+  lastUsedAt?: string | null;
+  createdAt?: string;
+  updatedAt?: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const ApiKey$inboundSchema: z.ZodType<ApiKey> = z.object({
+  resource: z.literal("api_key"),
+  id: z.union([z.number().int(), z.string()]).optional(),
+  description: z.string().optional(),
+  lastUsedAt: z.string().nullable().optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+})
+  .loose()
+  .transform((v) => remap$(v, { _links: "links" }) as ApiKey);

package/src/models/identity/index.ts

@@ -0,0 +1,9 @@
+/*
+ * Identity models.
+ */
+
+export * from "./users/index.js";
+export * from "./admin.js";
+export * from "./api-key.js";
+export * from "./me.js";
+export * from "./oauth2.js";

package/src/models/identity/me.ts

@@ -0,0 +1,17 @@
+/*
+ * /me response models.
+ */
+
+import * as z from "zod/v4";
+import { Admin, Admin$inboundSchema } from "./admin.js";
+import { ApiKey, ApiKey$inboundSchema } from "./api-key.js";
+import { User, User$inboundSchema } from "./users/user.js";
+
+export type MeResponse = User | Admin | ApiKey;
+
+/** @internal */
+export const MeResponse$inboundSchema: z.ZodType<MeResponse> = z.union([
+  User$inboundSchema,
+  Admin$inboundSchema,
+  ApiKey$inboundSchema,
+]);

package/src/models/identity/oauth2.ts

@@ -0,0 +1,116 @@
+/*
+ * OAuth2 identity models.
+ */
+
+import * as z from "zod/v4";
+
+export type OAuth2IssuedToken = {
+  token_type: string;
+  expires_in: number;
+  access_token: string;
+  refresh_token?: string | undefined;
+};
+
+/** @internal */
+export const OAuth2IssuedToken$inboundSchema: z.ZodType<OAuth2IssuedToken> = z
+  .object({
+    token_type: z.string(),
+    expires_in: z.number(),
+    access_token: z.string(),
+    refresh_token: z.string().optional(),
+  })
+  .loose();
+
+export type OAuth2Client = {
+  id: string | number;
+  user_id?: number | null | undefined;
+  name?: string | undefined;
+  secret?: string | null | undefined;
+  provider?: string | null | undefined;
+  redirect?: string | undefined;
+  personal_access_client?: boolean | undefined;
+  password_client?: boolean | undefined;
+  revoked?: boolean | undefined;
+  created_at?: string | null | undefined;
+  updated_at?: string | null | undefined;
+  plainSecret?: string | null | undefined;
+  grant_types?: Array<string> | undefined;
+  scopes?: Array<string> | undefined;
+};
+
+/** @internal */
+export const OAuth2Client$inboundSchema: z.ZodType<OAuth2Client> = z
+  .object({
+    id: z.union([z.string(), z.number()]),
+    user_id: z.number().nullable().optional(),
+    name: z.string().optional(),
+    secret: z.string().nullable().optional(),
+    provider: z.string().nullable().optional(),
+    redirect: z.string().optional(),
+    personal_access_client: z.boolean().optional(),
+    password_client: z.boolean().optional(),
+    revoked: z.boolean().optional(),
+    created_at: z.string().nullable().optional(),
+    updated_at: z.string().nullable().optional(),
+    plainSecret: z.string().nullable().optional(),
+    grant_types: z.array(z.string()).optional(),
+    scopes: z.array(z.string()).optional(),
+  })
+  .loose();
+
+export type OAuth2AuthorizedToken = {
+  id: string | number;
+  user_id?: number | null | undefined;
+  client_id?: string | number | null | undefined;
+  name?: string | null | undefined;
+  scopes?: Array<string> | undefined;
+  revoked?: boolean | undefined;
+  created_at?: string | null | undefined;
+  updated_at?: string | null | undefined;
+  expires_at?: string | null | undefined;
+  client?: OAuth2Client | undefined;
+};
+
+/** @internal */
+export const OAuth2AuthorizedToken$inboundSchema: z.ZodType<
+  OAuth2AuthorizedToken
+> = z.object({
+  id: z.union([z.string(), z.number()]),
+  user_id: z.number().nullable().optional(),
+  client_id: z.union([z.string(), z.number()]).nullable().optional(),
+  name: z.string().nullable().optional(),
+  scopes: z.array(z.string()).optional(),
+  revoked: z.boolean().optional(),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+  expires_at: z.string().nullable().optional(),
+  client: OAuth2Client$inboundSchema.optional(),
+}).loose();
+
+export type OAuth2Scope = {
+  id: string;
+  description: string;
+};
+
+/** @internal */
+export const OAuth2Scope$inboundSchema: z.ZodType<OAuth2Scope> = z.object({
+  id: z.string(),
+  description: z.string(),
+}).loose();
+
+export type OAuth2PersonalAccessTokenResult = {
+  accessToken: string;
+  token: OAuth2AuthorizedToken;
+};
+
+/** @internal */
+export const OAuth2PersonalAccessTokenResult$inboundSchema: z.ZodType<
+  OAuth2PersonalAccessTokenResult
+> = z.object({
+  accessToken: z.string().optional(),
+  access_token: z.string().optional(),
+  token: OAuth2AuthorizedToken$inboundSchema,
+}).transform((v) => ({
+  accessToken: v.accessToken ?? v.access_token ?? "",
+  token: v.token,
+}));

package/src/models/identity/user-mfa-method.ts

@@ -0,0 +1,42 @@
+/*
+ * User MFA Method model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type UserMfaMethod = {
+    resource: "user_mfa_method";
+    userId: number;
+    method: string;
+    isEnabled: boolean;
+    verifiedAt?: string | null;
+    lastUsedAt?: string | null;
+    lastSentAt?: string | null;
+    details?: {
+        qrCode?: string | undefined;
+        secret?: string | undefined;
+    } | undefined;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const UserMfaMethod$inboundSchema: z.ZodType<UserMfaMethod> = z.object({
+    resource: z.literal("user_mfa_method"),
+    userId: z.number().int(),
+    method: z.string(),
+    isEnabled: z.boolean(),
+    verifiedAt: z.string().nullable().optional(),
+    lastUsedAt: z.string().nullable().optional(),
+    lastSentAt: z.string().nullable().optional(),
+    details: z.object({
+        qrCode: z.string().optional(),
+        secret: z.string().optional(),
+    }).optional(),
+    _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as UserMfaMethod;
+});

package/src/models/identity/user-recovery-code.ts

@@ -0,0 +1,32 @@
+/*
+ * User Recovery Code model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type UserRecoveryCode = {
+    resource: "user_recovery_code";
+    id: number;
+    code: string;
+    usedAt?: string | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const UserRecoveryCode$inboundSchema: z.ZodType<UserRecoveryCode> = z.object({
+    resource: z.literal("user_recovery_code"),
+    id: z.number().int(),
+    code: z.string(),
+    usedAt: z.string().nullable().optional(),
+    createdAt: z.string().nullable().optional(),
+    updatedAt: z.string().nullable().optional(),
+    _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as UserRecoveryCode;
+});

package/src/models/identity/users/index.ts

@@ -0,0 +1,6 @@
+/*
+ * User models.
+ */
+
+export * from "./user.js";
+export * from "./user-login.js";

package/src/models/identity/users/user-login.ts

@@ -0,0 +1,52 @@
+/*
+ * User login model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../../hal.js";
+import { buildPaginated, Paginated } from "../../pagination.js";
+
+export type UserLogin = {
+  resource: "user_login";
+  id: number;
+  userId: number;
+  ipAddress?: string;
+  location?: string | null;
+  device?: string | null;
+  browser?: string | null;
+  userAgent?: string;
+  createdAt?: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const UserLogin$inboundSchema: z.ZodType<UserLogin> = z.object({
+  resource: z.literal("user_login"),
+  id: z.number().int(),
+  userId: z.number().int(),
+  ipAddress: z.string().optional(),
+  location: z.string().nullable().optional(),
+  device: z.string().nullable().optional(),
+  browser: z.string().nullable().optional(),
+  userAgent: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+})
+  .loose()
+  .transform((v) => remap$(v, { _links: "links" }) as UserLogin);
+
+export type UserLoginsListResponse = Paginated<UserLogin>;
+
+/** @internal */
+export const UserLoginsListResponse$inboundSchema: z.ZodType<
+  UserLoginsListResponse
+> = z.object({
+  _embedded: z.object({
+    user_logins: z.array(UserLogin$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(v._embedded.user_logins, v.count, v["_links"])
+);

package/src/models/identity/users/user.ts

@@ -0,0 +1,56 @@
+/*
+ * User model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../../hal.js";
+import { buildPaginated, Paginated } from "../../pagination.js";
+
+export type User = {
+  resource: "user";
+  id: number;
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+  avatar?: string | null;
+  language?: string | null;
+  isMfaEnabled?: boolean;
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const User$inboundSchema: z.ZodType<User> = z.object({
+  resource: z.literal("user"),
+  id: z.number().int(),
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+  email: z.string().optional(),
+  avatar: z.string().nullable().optional(),
+  language: z.string().nullable().optional(),
+  isMfaEnabled: z.boolean().optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+})
+  .loose()
+  .transform((v) =>
+    remap$(v, { _links: "links" }) as User
+  );
+
+export type UsersListResponse = Paginated<User>;
+
+/** @internal */
+export const UsersListResponse$inboundSchema: z.ZodType<
+  UsersListResponse
+> = z.object({
+  _embedded: z.object({
+    users: z.array(User$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(v._embedded.users, v.count, v["_links"])
+);

package/src/models/index.ts

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

package/src/models/localization/index.ts

@@ -0,0 +1,7 @@
+/*
+ * Localization models.
+ */
+
+export * from "./language.js";
+export * from "./locale.js";
+

package/src/models/localization/language.ts

@@ -0,0 +1,79 @@
+/*
+ * Localization language model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Locale, Locale$inboundSchema } from "./locale.js";
+
+export type Language = {
+  resource: "language";
+  id: number;
+  code: string;
+  name: string;
+  direction: string;
+  localeId: number;
+  flag?: string | null;
+  isActive: boolean;
+  parentId?: number | null;
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+  locale?: Locale;
+  parent?: Language | null;
+  children?: Language[];
+};
+
+/** @internal */
+export const Language$inboundSchema: z.ZodType<Language> = z.object({
+  resource: z.literal("language"),
+  id: z.number().int(),
+  code: z.string(),
+  name: z.string(),
+  direction: z.string(),
+  localeId: z.number().int(),
+  flag: z.string().nullable().optional(),
+  isActive: z.boolean(),
+  parentId: z.number().int().nullable().optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    locale: z.lazy(() => Locale$inboundSchema).optional(),
+    parent: z.lazy(() => Language$inboundSchema).nullable().optional(),
+    children: z.array(z.lazy(() => Language$inboundSchema)).optional(),
+  }).optional(),
+})
+  .loose()
+  .transform((v) => {
+    const out = remap$(v, { _links: "links" }) as Language;
+    const embedded = v["_embedded"];
+    if (embedded?.locale) {
+      out.locale = embedded.locale;
+    }
+    if (typeof embedded?.parent !== "undefined") {
+      out.parent = embedded.parent;
+    }
+    if (embedded?.children) {
+      out.children = embedded.children;
+    }
+    return out;
+  });
+
+export type LanguagesListResponse = Paginated<Language>;
+
+/** @internal */
+export const LanguagesListResponse$inboundSchema: z.ZodType<
+  LanguagesListResponse
+> = z.object({
+  _embedded: z.object({
+    languages: z.array(Language$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(v._embedded.languages, v.count, v["_links"])
+);
+

package/src/models/localization/locale.ts

@@ -0,0 +1,61 @@
+/*
+ * Localization locale model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Language, Language$inboundSchema } from "./language.js";
+
+export type Locale = {
+  resource: "locale";
+  id: number;
+  code: string;
+  name: string;
+  territory?: string | null;
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+  languages?: Language[];
+};
+
+/** @internal */
+export const Locale$inboundSchema: z.ZodType<Locale> = z.object({
+  resource: z.literal("locale"),
+  id: z.number().int(),
+  code: z.string(),
+  name: z.string(),
+  territory: z.string().nullable().optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    languages: z.array(z.lazy(() => Language$inboundSchema)).optional(),
+  }).optional(),
+})
+  .loose()
+  .transform((v) => {
+    const out = remap$(v, { _links: "links" }) as Locale;
+    const embedded = v["_embedded"];
+    if (embedded?.languages) {
+      out.languages = embedded.languages;
+    }
+    return out;
+  });
+
+export type LocalesListResponse = Paginated<Locale>;
+
+/** @internal */
+export const LocalesListResponse$inboundSchema: z.ZodType<
+  LocalesListResponse
+> = z.object({
+  _embedded: z.object({
+    locales: z.array(Locale$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(v._embedded.locales, v.count, v["_links"])
+);
+

package/src/models/operations/admins.ts

@@ -0,0 +1,67 @@
+/*
+ * Admin operations.
+ */
+
+import * as z from "zod/v4";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Admin, Admin$inboundSchema } from "../identity/admin.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+
+export type ListAdminsRequest = {
+    /**
+     * Page number.
+     */
+    page?: number | undefined;
+    /**
+     * Page limit.
+     */
+    limit?: number | undefined;
+};
+
+export type ListAdminsResponse = Paginated<Admin>;
+
+/** @internal */
+export const ListAdminsRequest$outboundSchema: z.ZodType<
+    ListAdminsRequest
+> = z.object({
+    page: z.number().optional(),
+    limit: z.number().optional(),
+});
+
+/** @internal */
+export const ListAdminsResponse$inboundSchema: z.ZodType<
+    ListAdminsResponse
+> = z.object({
+    _embedded: z.object({
+        admins: z.array(Admin$inboundSchema),
+    }),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+    buildPaginated(
+        v._embedded.admins,
+        v.count,
+        v._links,
+    )
+);
+
+export type GetAdminRequest = {
+    /**
+     * Admin ID.
+     */
+    id: number;
+};
+
+export type GetAdminResponse = Admin;
+
+/** @internal */
+export const GetAdminRequest$outboundSchema: z.ZodType<
+    GetAdminRequest
+> = z.object({
+    id: z.number(),
+});
+
+/** @internal */
+export const GetAdminResponse$inboundSchema: z.ZodType<
+    GetAdminResponse
+> = Admin$inboundSchema;