@ominity/api-typescript 1.0.0 → 1.1.1

package/src/models/operations/users-recovery-codes.ts

@@ -13,13 +13,16 @@ export type ListUserRecoveryCodesRequest = {
      */
     id: number;
     /**
-     * Page number.
+     * Sort by fields. Prefix with "-" for descending.
      */
-    page?: number | undefined;
+    sort?: string | undefined;
     /**
-     * Page limit.
+     * Filter query.
      */
-    limit?: number | undefined;
+    filter?: {
+        id?: number | undefined;
+        active?: boolean | undefined;
+    } | undefined;
 };
 
 export type ListUserRecoveryCodesResponse = Paginated<UserRecoveryCode>;
@@ -29,8 +32,11 @@ export const ListUserRecoveryCodesRequest$outboundSchema: z.ZodType<
     ListUserRecoveryCodesRequest
 > = z.object({
     id: z.number(),
-    page: z.number().optional(),
-    limit: z.number().optional(),
+    sort: z.string().optional(),
+    filter: z.object({
+        id: z.number().optional(),
+        active: z.boolean().optional(),
+    }).optional(),
 });
 
 /** @internal */
@@ -55,21 +61,38 @@ export type RegenerateRecoveryCodesRequest = {
      * User ID.
      */
     id: number;
+    /**
+     * Confirmation flag.
+     */
+    confirm: boolean;
 };
 
-export type RegenerateRecoveryCodesResponse = Array<UserRecoveryCode>;
+export type RegenerateRecoveryCodesResponse = Paginated<UserRecoveryCode>;
 
 /** @internal */
 export const RegenerateRecoveryCodesRequest$outboundSchema: z.ZodType<
     RegenerateRecoveryCodesRequest
 > = z.object({
     id: z.number(),
+    confirm: z.boolean(),
 });
 
 /** @internal */
 export const RegenerateRecoveryCodesResponse$inboundSchema: z.ZodType<
     RegenerateRecoveryCodesResponse
-> = z.array(UserRecoveryCode$inboundSchema);
+> = z.object({
+    _embedded: z.object({
+        user_recovery_codes: z.array(UserRecoveryCode$inboundSchema),
+    }),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+    buildPaginated(
+        v._embedded.user_recovery_codes,
+        v.count,
+        v._links,
+    )
+);
 
 export type ValidateRecoveryCodeRequest = {
     /**
@@ -82,7 +105,10 @@ export type ValidateRecoveryCodeRequest = {
     code: string;
 };
 
-export type ValidateRecoveryCodeResponse = void;
+export type ValidateRecoveryCodeResponse = {
+    success: boolean;
+    message: string;
+};
 
 /** @internal */
 export const ValidateRecoveryCodeRequest$outboundSchema: z.ZodType<
@@ -95,4 +121,7 @@ export const ValidateRecoveryCodeRequest$outboundSchema: z.ZodType<
 /** @internal */
 export const ValidateRecoveryCodeResponse$inboundSchema: z.ZodType<
     ValidateRecoveryCodeResponse
-> = z.void();
+> = z.object({
+    success: z.boolean(),
+    message: z.string(),
+}).loose();

package/src/models/operations/users.ts

@@ -3,6 +3,10 @@
  */
 
 import * as z from "zod/v4";
+import {
+  OAuth2IssuedToken,
+  OAuth2IssuedToken$inboundSchema,
+} from "../identity/oauth2.js";
 import { User, UsersListResponse } from "../identity/users/user.js";
 
 export type UsersListParams = {
@@ -50,6 +54,12 @@ export type UpdateUserRequest = {
 
 export type UpdateUserResponse = User;
 
+export type IssueUserAccessTokenRequest = {
+  id: number | string;
+};
+
+export type IssueUserAccessTokenResponse = OAuth2IssuedToken;
+
 /** @internal */
 export const UsersListParams$outboundSchema: z.ZodType<UsersListParams> = z
   .object({
@@ -94,3 +104,15 @@ export const UpdateUserRequest$outboundSchema: z.ZodType<UpdateUserRequest> = z
       password: z.string().optional(),
     }).loose(),
   }).transform((v) => v as UpdateUserRequest);
+
+/** @internal */
+export const IssueUserAccessTokenRequest$outboundSchema: z.ZodType<
+  IssueUserAccessTokenRequest
+> = z.object({
+  id: z.union([z.string(), z.number()]),
+}).loose();
+
+/** @internal */
+export const IssueUserAccessTokenResponse$inboundSchema: z.ZodType<
+  IssueUserAccessTokenResponse
+> = OAuth2IssuedToken$inboundSchema;

package/src/models/settings/index.ts

@@ -1,3 +1,4 @@
 export * from "./country.js";
 export * from "./social-provider.js";
+export * from "./social-provider-link.js";
 export * from "./payment-method.js";

package/src/models/settings/social-provider-link.ts

@@ -0,0 +1,31 @@
+/*
+ * Social Provider Link model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type SocialProviderLink = {
+  resource: "socialprovider_link";
+  providerId: number;
+  redirectUrl: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const SocialProviderLink$inboundSchema: z.ZodType<SocialProviderLink> = z
+  .object({
+    resource: z.literal("socialprovider_link"),
+    providerId: z.number().int(),
+    redirectUrl: z.string(),
+    createdAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+  })
+  .loose()
+  .transform((v) =>
+    remap$(v, {
+      _links: "links",
+    }) as SocialProviderLink
+  );

package/src/models/settings/social-provider-user.ts

@@ -9,10 +9,11 @@ import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
 export type SocialProviderUser = {
     resource: "socialprovider_user";
     id: number;
-    userId: number;
-    provider: string;
+    providerId: number;
+    userId?: number | null;
     identifier?: string;
     name?: string;
+    email?: string | null;
     avatar?: string | null;
     updatedAt: string;
     createdAt: string;
@@ -23,10 +24,11 @@ export type SocialProviderUser = {
 export const SocialProviderUser$inboundSchema: z.ZodType<SocialProviderUser> = z.object({
     resource: z.literal("socialprovider_user"),
     id: z.number().int(),
-    userId: z.number().int(),
-    provider: z.string(),
+    providerId: z.number().int(),
+    userId: z.number().int().nullable().optional(),
     identifier: z.string().optional(),
     name: z.string().optional(),
+    email: z.string().nullable().optional(),
     avatar: z.string().nullable().optional(),
     updatedAt: z.string(),
     createdAt: z.string(),

package/src/sdk/oauth2.ts

@@ -0,0 +1,155 @@
+/*
+ * OAuth2 SDK.
+ */
+
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+import * as operations from "../models/operations/index.js";
+import {
+  oauth2CreateClient,
+  oauth2CreatePersonalAccessToken,
+  oauth2DeleteClient,
+  oauth2DeletePersonalAccessToken,
+  oauth2IssueToken,
+  oauth2ListAuthorizedTokens,
+  oauth2ListClients,
+  oauth2ListPersonalAccessTokens,
+  oauth2ListScopes,
+  oauth2RefreshTransientTokenCookie,
+  oauth2RevokeAuthorizedToken,
+  oauth2UpdateClient,
+} from "../funcs/oauth2/index.js";
+
+export class OAuth2 extends ClientSDK {
+  async issueToken(
+    request: operations.IssueOAuth2TokenRequest,
+    options?: RequestOptions,
+  ): Promise<operations.IssueOAuth2TokenResponse> {
+    return unwrapAsync(oauth2IssueToken(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async refreshTransientTokenCookie(
+    request?: operations.RefreshTransientTokenCookieRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.RefreshTransientTokenCookieResponse> {
+    return unwrapAsync(oauth2RefreshTransientTokenCookie(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listAuthorizedTokens(
+    request?: operations.ListAuthorizedTokensRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListAuthorizedTokensResponse> {
+    return unwrapAsync(oauth2ListAuthorizedTokens(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async revokeAuthorizedToken(
+    request: operations.RevokeAuthorizedTokenRequest,
+    options?: RequestOptions,
+  ): Promise<operations.RevokeAuthorizedTokenResponse> {
+    return unwrapAsync(oauth2RevokeAuthorizedToken(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listClients(
+    request?: operations.ListOAuthClientsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListOAuthClientsResponse> {
+    return unwrapAsync(oauth2ListClients(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async createClient(
+    request: operations.CreateOAuthClientRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateOAuthClientResponse> {
+    return unwrapAsync(oauth2CreateClient(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async updateClient(
+    request: operations.UpdateOAuthClientRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateOAuthClientResponse> {
+    return unwrapAsync(oauth2UpdateClient(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async deleteClient(
+    request: operations.DeleteOAuthClientRequest,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteOAuthClientResponse> {
+    return unwrapAsync(oauth2DeleteClient(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listScopes(
+    request?: operations.ListOAuthScopesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListOAuthScopesResponse> {
+    return unwrapAsync(oauth2ListScopes(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listPersonalAccessTokens(
+    request?: operations.ListPersonalAccessTokensRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListPersonalAccessTokensResponse> {
+    return unwrapAsync(oauth2ListPersonalAccessTokens(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async createPersonalAccessToken(
+    request: operations.CreatePersonalAccessTokenRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreatePersonalAccessTokenResponse> {
+    return unwrapAsync(oauth2CreatePersonalAccessToken(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async deletePersonalAccessToken(
+    request: operations.DeletePersonalAccessTokenRequest,
+    options?: RequestOptions,
+  ): Promise<operations.DeletePersonalAccessTokenResponse> {
+    return unwrapAsync(oauth2DeletePersonalAccessToken(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -6,6 +6,7 @@ import { Commerce } from "./commerce/index.js";
 import { Http } from "./http.js";
 import { Localization } from "./localization/index.js";
 import { Me } from "./me.js";
+import { OAuth2 } from "./oauth2.js";
 import { Settings } from "./settings/index.js";
 import { Users } from "./users/index.js";
 import { Admins } from "./admins.js";
@@ -70,6 +71,11 @@ export class Ominity extends ClientSDK {
     return (this._localization ??= new Localization(this._options));
   }
 
+  private _oauth2?: OAuth2;
+  get oauth2(): OAuth2 {
+    return (this._oauth2 ??= new OAuth2(this._options));
+  }
+
   private _me?: Me;
   get me(): Me {
     return (this._me ??= new Me(this._options));

package/src/sdk/settings/social-providers.ts

@@ -1,5 +1,11 @@
 import { socialProvidersGet } from "../../funcs/settings/socialProvidersGet.js";
 import { socialProvidersList } from "../../funcs/settings/socialProvidersList.js";
+import { socialProvidersCreateLink } from "../../funcs/settings/socialProvidersCreateLink.js";
+import { socialProviderUsersExchangeAccessCode } from "../../funcs/settings/socialProviderUsersExchangeAccessCode.js";
+import { socialProviderUsersList } from "../../funcs/settings/socialProviderUsersList.js";
+import { socialProviderUsersGet } from "../../funcs/settings/socialProviderUsersGet.js";
+import { socialProviderUsersUpdate } from "../../funcs/settings/socialProviderUsersUpdate.js";
+import { socialProviderUsersDelete } from "../../funcs/settings/socialProviderUsersDelete.js";
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import * as operations from "../../models/operations/index.js";
 import { unwrapAsync } from "../../types/fp.js";
@@ -32,4 +38,88 @@ export class SocialProviders extends ClientSDK {
             options,
         ));
     }
+
+    /**
+     * Create social provider redirect link.
+     */
+    async createLink(
+        request: operations.CreateSocialProviderLinkRequest,
+        options?: RequestOptions,
+    ): Promise<operations.CreateSocialProviderLinkResponse> {
+        return unwrapAsync(socialProvidersCreateLink(
+            this,
+            request,
+            options,
+        ));
+    }
+
+    /**
+     * Exchange social provider access code.
+     */
+    async exchangeAccessCode(
+        request: operations.ExchangeSocialProviderAccessCodeRequest,
+        options?: RequestOptions,
+    ): Promise<operations.ExchangeSocialProviderAccessCodeResponse> {
+        return unwrapAsync(socialProviderUsersExchangeAccessCode(
+            this,
+            request,
+            options,
+        ));
+    }
+
+    /**
+     * List social provider users.
+     */
+    async listUsers(
+        request: operations.ListSocialProviderUsersRequest,
+        options?: RequestOptions,
+    ): Promise<operations.ListSocialProviderUsersResponse> {
+        return unwrapAsync(socialProviderUsersList(
+            this,
+            request,
+            options,
+        ));
+    }
+
+    /**
+     * Get social provider user.
+     */
+    async getUser(
+        request: operations.GetSocialProviderUserRequest,
+        options?: RequestOptions,
+    ): Promise<operations.GetSocialProviderUserResponse> {
+        return unwrapAsync(socialProviderUsersGet(
+            this,
+            request,
+            options,
+        ));
+    }
+
+    /**
+     * Update social provider user.
+     */
+    async updateUser(
+        request: operations.UpdateSocialProviderUserRequest,
+        options?: RequestOptions,
+    ): Promise<operations.UpdateSocialProviderUserResponse> {
+        return unwrapAsync(socialProviderUsersUpdate(
+            this,
+            request,
+            options,
+        ));
+    }
+
+    /**
+     * Delete social provider user.
+     */
+    async deleteUser(
+        request: operations.DeleteSocialProviderUserRequest,
+        options?: RequestOptions,
+    ): Promise<operations.DeleteSocialProviderUserResponse> {
+        return unwrapAsync(socialProviderUsersDelete(
+            this,
+            request,
+            options,
+        ));
+    }
 }

package/src/sdk/users/customers.ts

@@ -0,0 +1,21 @@
+/*
+ * User customers SDK.
+ */
+
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { unwrapAsync } from "../../types/fp.js";
+import * as operations from "../../models/operations/index.js";
+import { usersListCustomers } from "../../funcs/users/usersListCustomers.js";
+
+export class UserCustomers extends ClientSDK {
+  async list(
+    request: operations.ListUserCustomersRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ListUserCustomersResponse> {
+    return unwrapAsync(usersListCustomers(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/users/index.ts

@@ -7,27 +7,44 @@ import { unwrapAsync } from "../../types/fp.js";
 import * as operations from "../../models/operations/index.js";
 import { usersCreate } from "../../funcs/users/usersCreate.js";
 import { usersGet } from "../../funcs/users/usersGet.js";
+import { usersIssueToken } from "../../funcs/users/usersIssueToken.js";
 import { usersList } from "../../funcs/users/usersList.js";
 import { usersUpdate } from "../../funcs/users/usersUpdate.js";
-import { usersListCustomers } from "../../funcs/users/usersListCustomers.js";
-import { usersListOAuthAccounts } from "../../funcs/users/usersListOAuthAccounts.js";
-import { usersListMfaMethods } from "../../funcs/users/usersListMfaMethods.js";
-import { usersEnableMfa } from "../../funcs/users/usersEnableMfa.js";
-import { usersDisableMfa } from "../../funcs/users/usersDisableMfa.js";
-import { usersValidateMfa } from "../../funcs/users/usersValidateMfa.js";
-import { usersSendMfa } from "../../funcs/users/usersSendMfa.js";
-import { usersListRecoveryCodes } from "../../funcs/users/usersListRecoveryCodes.js";
-import { usersRegenerateRecoveryCodes } from "../../funcs/users/usersRegenerateRecoveryCodes.js";
-import { usersValidateRecoveryCode } from "../../funcs/users/usersValidateRecoveryCode.js";
+import { usersSendPasswordResetLink } from "../../funcs/users/usersSendPasswordResetLink.js";
+import { usersResetPassword } from "../../funcs/users/usersResetPassword.js";
+import { UserCustomers } from "./customers.js";
 import { UserLogins } from "./logins.js";
+import { UserMfaMethods } from "./mfa-methods.js";
+import { UserOAuthAccounts } from "./oauth-accounts.js";
+import { UserRecoveryCodes } from "./recovery-codes.js";
 
 export class Users extends ClientSDK {
   private _logins?: UserLogins;
+  private _customers?: UserCustomers;
+  private _oauthAccounts?: UserOAuthAccounts;
+  private _mfaMethods?: UserMfaMethods;
+  private _recoveryCodes?: UserRecoveryCodes;
 
   get logins(): UserLogins {
     return (this._logins ??= new UserLogins(this._options));
   }
 
+  get customers(): UserCustomers {
+    return (this._customers ??= new UserCustomers(this._options));
+  }
+
+  get oauthAccounts(): UserOAuthAccounts {
+    return (this._oauthAccounts ??= new UserOAuthAccounts(this._options));
+  }
+
+  get mfaMethods(): UserMfaMethods {
+    return (this._mfaMethods ??= new UserMfaMethods(this._options));
+  }
+
+  get recoveryCodes(): UserRecoveryCodes {
+    return (this._recoveryCodes ??= new UserRecoveryCodes(this._options));
+  }
+
   async list(
     request?: operations.UsersListParams | undefined,
     options?: RequestOptions,
@@ -72,110 +89,33 @@ export class Users extends ClientSDK {
     ));
   }
 
-  async listCustomers(
-    request: operations.ListUserCustomersRequest,
-    options?: RequestOptions,
-  ): Promise<operations.ListUserCustomersResponse> {
-    return unwrapAsync(usersListCustomers(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  async listOAuthAccounts(
-    request: operations.ListUserOAuthAccountsRequest,
-    options?: RequestOptions,
-  ): Promise<operations.ListUserOAuthAccountsResponse> {
-    return unwrapAsync(usersListOAuthAccounts(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  async listMfaMethods(
-    request: operations.ListUserMfaMethodsRequest,
-    options?: RequestOptions,
-  ): Promise<operations.ListUserMfaMethodsResponse> {
-    return unwrapAsync(usersListMfaMethods(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  async enableMfa(
-    request: operations.EnableMfaRequest,
-    options?: RequestOptions,
-  ): Promise<operations.EnableMfaResponse> {
-    return unwrapAsync(usersEnableMfa(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  async disableMfa(
-    request: operations.DisableMfaRequest,
-    options?: RequestOptions,
-  ): Promise<operations.DisableMfaResponse> {
-    return unwrapAsync(usersDisableMfa(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  async validateMfa(
-    request: operations.ValidateMfaRequest,
-    options?: RequestOptions,
-  ): Promise<operations.ValidateMfaResponse> {
-    return unwrapAsync(usersValidateMfa(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  async sendMfa(
-    request: operations.SendMfaRequest,
-    options?: RequestOptions,
-  ): Promise<operations.SendMfaResponse> {
-    return unwrapAsync(usersSendMfa(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  async listRecoveryCodes(
-    request: operations.ListUserRecoveryCodesRequest,
+  async issueToken(
+    request: operations.IssueUserAccessTokenRequest,
     options?: RequestOptions,
-  ): Promise<operations.ListUserRecoveryCodesResponse> {
-    return unwrapAsync(usersListRecoveryCodes(
+  ): Promise<operations.IssueUserAccessTokenResponse> {
+    return unwrapAsync(usersIssueToken(
       this,
       request,
       options,
     ));
   }
 
-  async regenerateRecoveryCodes(
-    request: operations.RegenerateRecoveryCodesRequest,
+  async sendPasswordResetLink(
+    request: operations.SendPasswordResetLinkRequest,
     options?: RequestOptions,
-  ): Promise<operations.RegenerateRecoveryCodesResponse> {
-    return unwrapAsync(usersRegenerateRecoveryCodes(
+  ): Promise<operations.SendPasswordResetLinkResponse> {
+    return unwrapAsync(usersSendPasswordResetLink(
       this,
       request,
       options,
     ));
   }
 
-  async validateRecoveryCode(
-    request: operations.ValidateRecoveryCodeRequest,
+  async resetPassword(
+    request: operations.ResetPasswordRequest,
     options?: RequestOptions,
-  ): Promise<operations.ValidateRecoveryCodeResponse> {
-    return unwrapAsync(usersValidateRecoveryCode(
+  ): Promise<operations.ResetPasswordResponse> {
+    return unwrapAsync(usersResetPassword(
       this,
       request,
       options,