@ominity/api-typescript 1.0.0 → 1.1.1

package/src/funcs/users/usersResetPassword.ts

@@ -0,0 +1,172 @@
+/*
+ * Reset user password.
+ */
+
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import {
+  encodeJSON,
+} from "../../lib/encodings.js";
+import * as M from "../../lib/matchers.js";
+import { safeParse } from "../../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import * as errors from "../../models/errors/index.js";
+import { ResponseValidationError } from "../../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import * as operations from "../../models/operations/index.js";
+import { ResetPasswordResponse$inboundSchema } from "../../models/operations/users-password-reset.js";
+import { APICall, APIPromise } from "../../types/async.js";
+import { Result } from "../../types/fp.js";
+
+export function usersResetPassword(
+  client: ClientSDK,
+  request: operations.ResetPasswordRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.ResetPasswordResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: ClientSDK,
+  request: operations.ResetPasswordRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.ResetPasswordResponse,
+      | errors.ErrorResponse
+      | errors.OminityDefaultError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.ResetPasswordRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const path = "/users/password-reset/update";
+
+  const headers = new Headers({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  });
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "users.resetPassword",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 2,
+          maxElapsedTime: 7500,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["5xx"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    operations.ResetPasswordResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, ResetPasswordResponse$inboundSchema, {
+      ctype: "application/json",
+    }),
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/users/usersSendMfa.ts

@@ -22,7 +22,7 @@ import {
 import * as operations from "../../models/operations/index.js";
 import { SendMfaResponse$inboundSchema } from "../../models/operations/users-mfa.js";
 import { APICall, APIPromise } from "../../types/async.js";
-import { OK, Result } from "../../types/fp.js";
+import { Result } from "../../types/fp.js";
 
 export function usersSendMfa(
     client: ClientSDK,
@@ -89,7 +89,7 @@ async function $do(
     ) || "";
 
     const headers = new Headers({
-        Accept: "*/*",
+        Accept: "application/json",
     });
 
     const securityInput = await extractSecurity(client._options.security);
@@ -160,7 +160,9 @@ async function $do(
         | UnexpectedClientError
         | SDKValidationError
     >(
-        M.nil("2XX", SendMfaResponse$inboundSchema),
+        M.json(200, SendMfaResponse$inboundSchema, {
+            ctype: "application/json",
+        }),
         M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
             ctype: "application/hal+json",
         }),
@@ -170,8 +172,5 @@ async function $do(
         return [result, { status: "complete", request: req, response }];
     }
 
-    return [
-        OK(result.value),
-        { status: "complete", request: req, response },
-    ];
+    return [result, { status: "complete", request: req, response }];
 }

package/src/funcs/users/usersSendPasswordResetLink.ts

@@ -0,0 +1,172 @@
+/*
+ * Send user password reset link.
+ */
+
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import {
+  encodeJSON,
+} from "../../lib/encodings.js";
+import * as M from "../../lib/matchers.js";
+import { safeParse } from "../../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import * as errors from "../../models/errors/index.js";
+import { ResponseValidationError } from "../../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import * as operations from "../../models/operations/index.js";
+import { SendPasswordResetLinkResponse$inboundSchema } from "../../models/operations/users-password-reset.js";
+import { APICall, APIPromise } from "../../types/async.js";
+import { Result } from "../../types/fp.js";
+
+export function usersSendPasswordResetLink(
+  client: ClientSDK,
+  request: operations.SendPasswordResetLinkRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.SendPasswordResetLinkResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: ClientSDK,
+  request: operations.SendPasswordResetLinkRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.SendPasswordResetLinkResponse,
+      | errors.ErrorResponse
+      | errors.OminityDefaultError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.SendPasswordResetLinkRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const path = "/users/password-reset/send";
+
+  const headers = new Headers({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  });
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "users.sendPasswordResetLink",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 2,
+          maxElapsedTime: 7500,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["5xx"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    operations.SendPasswordResetLinkResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, SendPasswordResetLinkResponse$inboundSchema, {
+      ctype: "application/json",
+    }),
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/users/usersValidateMfa.ts

@@ -23,7 +23,7 @@ import {
 import * as operations from "../../models/operations/index.js";
 import { ValidateMfaResponse$inboundSchema } from "../../models/operations/users-mfa.js";
 import { APICall, APIPromise } from "../../types/async.js";
-import { OK, Result } from "../../types/fp.js";
+import { Result } from "../../types/fp.js";
 
 export function usersValidateMfa(
     client: ClientSDK,
@@ -91,7 +91,7 @@ async function $do(
 
     const headers = new Headers({
         "Content-Type": "application/json",
-        Accept: "application/hal+json",
+        Accept: "application/json",
     });
 
     const securityInput = await extractSecurity(client._options.security);
@@ -163,7 +163,7 @@ async function $do(
         | SDKValidationError
     >(
         M.json(200, ValidateMfaResponse$inboundSchema, {
-            ctype: "application/hal+json",
+            ctype: "application/json",
         }),
         M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
             ctype: "application/hal+json",
@@ -174,8 +174,5 @@ async function $do(
         return [result, { status: "complete", request: req, response }];
     }
 
-    return [
-        OK(result.value),
-        { status: "complete", request: req, response },
-    ];
+    return [result, { status: "complete", request: req, response }];
 }

package/src/funcs/users/usersValidateRecoveryCode.ts

@@ -23,7 +23,7 @@ import {
 import * as operations from "../../models/operations/index.js";
 import { ValidateRecoveryCodeResponse$inboundSchema } from "../../models/operations/users-recovery-codes.js";
 import { APICall, APIPromise } from "../../types/async.js";
-import { OK, Result } from "../../types/fp.js";
+import { Result } from "../../types/fp.js";
 
 export function usersValidateRecoveryCode(
     client: ClientSDK,
@@ -91,7 +91,7 @@ async function $do(
 
     const headers = new Headers({
         "Content-Type": "application/json",
-        Accept: "*/*",
+        Accept: "application/json",
     });
 
     const securityInput = await extractSecurity(client._options.security);
@@ -162,7 +162,9 @@ async function $do(
         | UnexpectedClientError
         | SDKValidationError
     >(
-        M.nil("2XX", ValidateRecoveryCodeResponse$inboundSchema),
+        M.json(200, ValidateRecoveryCodeResponse$inboundSchema, {
+            ctype: "application/json",
+        }),
         M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
             ctype: "application/hal+json",
         }),
@@ -172,8 +174,5 @@ async function $do(
         return [result, { status: "complete", request: req, response }];
     }
 
-    return [
-        OK(result.value),
-        { status: "complete", request: req, response },
-    ];
+    return [result, { status: "complete", request: req, response }];
 }

package/src/lib/config.ts

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

package/src/lib/url.ts

@@ -28,3 +28,35 @@ export function pathToFunc(
     });
   };
 }
+
+/**
+ * Returns a copy of a base URL with the configured API version suffix removed.
+ * Useful for endpoints that are mounted outside `/api/{version}`.
+ */
+export function baseURLWithoutAPIVersion(
+  baseURL: string | URL | null | undefined,
+  apiVersion: string | undefined,
+): URL | undefined {
+  if (!baseURL) {
+    return undefined;
+  }
+
+  const normalizedVersion = apiVersion ?? "v1";
+  const url = new URL(baseURL.toString());
+
+  const pathname = url.pathname.replace(/\/+$/, "");
+  const versionSuffix = normalizedVersion ? `/${normalizedVersion}` : "";
+
+  if (versionSuffix && pathname.endsWith(versionSuffix)) {
+    const nextPath = pathname.slice(0, -versionSuffix.length);
+    url.pathname = `${nextPath || "/"}`;
+  } else {
+    url.pathname = `${pathname || "/"}`;
+  }
+
+  if (!url.pathname.endsWith("/")) {
+    url.pathname = `${url.pathname}/`;
+  }
+
+  return url;
+}

package/src/models/identity/index.ts

@@ -6,3 +6,4 @@ 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/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

@@ -14,6 +14,10 @@ export type UserMfaMethod = {
     verifiedAt?: string | null;
     lastUsedAt?: string | null;
     lastSentAt?: string | null;
+    details?: {
+        qrCode?: string | undefined;
+        secret?: string | undefined;
+    } | undefined;
     links?: HalLinks;
 };
 
@@ -26,6 +30,10 @@ export const UserMfaMethod$inboundSchema: z.ZodType<UserMfaMethod> = z.object({
     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, {

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

@@ -8,24 +8,22 @@ import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
 
 export type UserRecoveryCode = {
     resource: "user_recovery_code";
-    userId: number;
+    id: number;
     code: string;
-    isUsed: boolean;
     usedAt?: string | null;
-    createdAt: string;
-    updatedAt: string;
+    createdAt?: string | null;
+    updatedAt?: string | null;
     links?: HalLinks;
 };
 
 /** @internal */
 export const UserRecoveryCode$inboundSchema: z.ZodType<UserRecoveryCode> = z.object({
     resource: z.literal("user_recovery_code"),
-    userId: z.number().int(),
+    id: z.number().int(),
     code: z.string(),
-    isUsed: z.boolean(),
     usedAt: z.string().nullable().optional(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
+    createdAt: z.string().nullable().optional(),
+    updatedAt: z.string().nullable().optional(),
     _links: HalLinks$inboundSchema.optional(),
 }).loose().transform((v) => {
     return remap$(v, {

package/src/models/operations/index.ts

@@ -23,12 +23,14 @@ export * from "./localization-languages.js";
 export * from "./localization-locales.js";
 export * from "./me.js";
 export * from "./users.js";
+export * from "./users-password-reset.js";
 export * from "./users-logins.js";
 export * from "./admins.js";
 export * from "./users-customers.js";
 export * from "./users-oauth-accounts.js";
 export * from "./users-mfa.js";
 export * from "./users-recovery-codes.js";
+export * from "./oauth2.js";
 export * from "./channels.js";
 export * from "./channel-types.js";
 export * from "./channel-domains.js";