@palmetto/users-sdk 1.7.0 → 1.7.2

package/dist/__generated__/schema.d.ts

@@ -16,6 +16,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/auth/otp-channels": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get available OTP channels for user
+         * @description Returns masked contact options for OTP delivery. Returns empty array for unknown users to prevent enumeration.
+         */
+        get: operations["AuthController_getOtpChannels"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/otp-challenge": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Request OTP code
+         * @description Sends a 6-digit OTP code via the specified channel (email or SMS)
+         */
+        post: operations["AuthController_requestOtpChallenge"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/organizations/{id}": {
         parameters: {
             query?: never;
@@ -444,6 +484,25 @@ export interface components {
             /** @enum {string} */
             grant_type: "refresh_token";
             refresh_token: string;
+        } | {
+            /** @enum {string} */
+            grant_type: "https://users.palmetto.com/oauth/grant-types/otp-challenge";
+            /**
+             * Format: email
+             * @description Email address used to request the OTP
+             * @example john.doe@palmetto.com
+             */
+            identifier: string;
+            /**
+             * @description 6-digit OTP code received via email or SMS
+             * @example 123456
+             */
+            otp: string;
+            /**
+             * @description Channel where the OTP was delivered
+             * @enum {string}
+             */
+            channel: "EMAIL" | "SMS";
         };
         /** TokenResponse */
         TokenResponseDto: {
@@ -480,6 +539,23 @@ export interface components {
                 [key: string]: string[];
             };
         };
+        /** UnauthorizedError */
+        UnauthorizedErrorDto: {
+            /**
+             * @example Unauthorized
+             * @enum {string}
+             */
+            error: "Unauthorized";
+            /**
+             * @example 401
+             * @enum {number}
+             */
+            statusCode: 401;
+            /** @example You must log in to perform that action */
+            message: string;
+            /** @example Technical error description */
+            reason: string;
+        };
         /** NotFoundError */
         NotFoundErrorDto: {
             /**
@@ -497,22 +573,49 @@ export interface components {
             /** @example Technical error description */
             reason: string;
         };
-        /** UnauthorizedError */
-        UnauthorizedErrorDto: {
+        /** List */
+        ListDto: {
+            data: unknown[];
+        };
+        /** OtpChannelOption */
+        OtpChannelOptionDto: {
             /**
-             * @example Unauthorized
+             * @description Available authentication channel
              * @enum {string}
              */
-            error: "Unauthorized";
+            channel: "EMAIL" | "SMS";
             /**
-             * @example 401
-             * @enum {number}
+             * @description Privacy-masked contact information
+             * @example j******@palmetto.com
              */
-            statusCode: 401;
-            /** @example You must log in to perform that action */
-            message: string;
-            /** @example Technical error description */
-            reason: string;
+            maskedIdentifier: string;
+        };
+        /** OtpChallengeInput */
+        OtpChallengeInputDto: {
+            /**
+             * Format: email
+             * @description Email address for OTP delivery
+             * @example john.doe@palmetto.com
+             */
+            identifier: string;
+            /**
+             * @description Delivery channel for OTP code
+             * @enum {string}
+             */
+            channel: "EMAIL" | "SMS";
+        };
+        /** OtpChallenge */
+        OtpChallengeDto: {
+            /**
+             * @description Privacy-masked destination where OTP was sent
+             * @example j******@palmetto.com
+             */
+            maskedIdentifier: string;
+            /**
+             * @description OTP validity period in seconds (typically 300 for 5 minutes)
+             * @example 300
+             */
+            expiresIn: number;
         };
         /** Organization */
         OrganizationDto: {
@@ -612,10 +715,6 @@ export interface components {
              */
             name: string;
         };
-        /** List */
-        ListDto: {
-            data: unknown[];
-        };
         /** Grant */
         GrantDto: {
             /**
@@ -700,7 +799,7 @@ export interface components {
              * @description Internal auth id
              * @example auth0|1234567890
              */
-            auth0Id: string | null;
+            auth0Id?: string | null;
             /**
              * Format: email
              * @description Email
@@ -805,7 +904,7 @@ export interface components {
              * @description Internal auth id
              * @example auth0|1234567890
              */
-            auth0Id: string | null;
+            auth0Id?: string | null;
             /**
              * Format: email
              * @description Email
@@ -844,7 +943,7 @@ export interface components {
              * @description Auth0 ID
              * @example auth0|1234567890
              */
-            auth0Id: string;
+            auth0Id?: string;
             /**
              * Format: email
              * @description Email
@@ -865,7 +964,7 @@ export interface components {
              * @description Phone number
              * @example +18048675309
              */
-            phoneNumber: string;
+            phoneNumber?: string;
             /** @example 66e25e72d10dfef2f9f6cc60 */
             organizationId: string;
             /** @default [] */
@@ -1256,7 +1355,7 @@ export interface components {
              * @description Internal auth id
              * @example auth0|1234567890
              */
-            auth0Id: string | null;
+            auth0Id?: string | null;
             /**
              * Format: email
              * @description Email
@@ -1385,6 +1484,15 @@ export interface operations {
                     "application/json": components["schemas"]["BadRequestErrorDto"];
                 };
             };
+            /** @description When OTP code is invalid or expired */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
+                };
+            };
             /** @description When the user does not exist for the exchange token */
             404: {
                 headers: {
@@ -1396,6 +1504,98 @@ export interface operations {
             };
         };
     };
+    AuthController_getOtpChannels: {
+        parameters: {
+            query: {
+                /** @description Email address to look up available OTP channels */
+                identifier: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["OtpChannelOptionDto"][];
+                    };
+                };
+            };
+            /** @description When the identifier is invalid */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BadRequestErrorDto"];
+                };
+            };
+            /** @description When authentication fails */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
+                };
+            };
+        };
+    };
+    AuthController_requestOtpChallenge: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["OtpChallengeInputDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OtpChallengeDto"];
+                };
+            };
+            /** @description When the request is invalid or channel is unavailable */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BadRequestErrorDto"];
+                };
+            };
+            /** @description When authentication fails */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
+                };
+            };
+            /** @description When the user does not exist */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotFoundErrorDto"];
+                };
+            };
+        };
+    };
     OrganizationsController_getOrganization: {
         parameters: {
             query?: never;

package/dist/client.d.ts

@@ -30,6 +30,8 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
     getAuthToken({ code, skipUserVerification }: GetAuthTokenInput, opts?: RequestOptions): Promise<GetTokenResult>;
     refreshToken({ refreshToken }: RefreshTokenInput, opts?: RequestOptions): Promise<GetTokenResult>;
     private getToken;
+    getOtpChannels(input: GetOtpChannelsInput, opts?: RequestOptions): Promise<GetOtpChannelsResult>;
+    requestOtpChallenge(input: RequestOtpChallengeInput, opts?: RequestOptions): Promise<RequestOtpChallengeResult>;
     getServices(_input: GetServicesInput, opts?: RequestOptions): Promise<GetServicesResult>;
     createService(input: CreateServiceInput, opts?: RequestOptions): Promise<CreateServiceResult>;
     getService(input: GetServiceInput, opts?: RequestOptions): Promise<GetServiceResult>;
@@ -144,3 +146,9 @@ export interface GetTokenResponse {
     expiresIn: number;
 }
 export type GetTokenResult = ResultOk<GetTokenResponse> | SdkError<ApiError<paths["/api/auth/token"]["post"]["responses"]>>;
+export type GetOtpChannelsInput = ApiInput<paths["/api/auth/otp-channels"]["get"]>;
+export type GetOtpChannelsResult = SdkResult<paths["/api/auth/otp-channels"]["get"]>;
+export type GetOtpChannelsResponse = ExtractResultData<GetOtpChannelsResult>;
+export type RequestOtpChallengeInput = ApiInput<paths["/api/auth/otp-challenge"]["post"]>;
+export type RequestOtpChallengeResult = SdkResult<paths["/api/auth/otp-challenge"]["post"]>;
+export type RequestOtpChallengeResponse = ExtractResultData<RequestOtpChallengeResult>;

package/dist/client.js

@@ -23,7 +23,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UsersApiClient = void 0;
 const base_sdk_client_1 = require("@palmetto/base-sdk-client");
 const result_1 = require("@palmetto/result");
-const SDK_VERSION_SLUG = "palmetto-users-sdk/1.7.0";
+const SDK_VERSION_SLUG = "palmetto-users-sdk/1.7.2";
 class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
     constructor(input) {
         super(Object.assign(Object.assign({}, input), { sdkVersion: SDK_VERSION_SLUG }));
@@ -366,6 +366,30 @@ class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
             return this.handleErrorResponse(error, response);
         });
     }
+    getOtpChannels(input, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error, response } = yield this.client.GET("/api/auth/otp-channels", {
+                params: { query: input },
+                headers: this.generateHeaders(opts),
+            });
+            if (data) {
+                return (0, result_1.Ok)(data);
+            }
+            return this.handleErrorResponse(error, response);
+        });
+    }
+    requestOtpChallenge(input, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error, response } = yield this.client.POST("/api/auth/otp-challenge", {
+                body: input,
+                headers: this.generateHeaders(opts),
+            });
+            if (data) {
+                return (0, result_1.Ok)(data);
+            }
+            return this.handleErrorResponse(error, response);
+        });
+    }
     getServices(_input, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const { data, error, response } = yield this.client.GET("/api/services", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palmetto/users-sdk",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "main": "./dist/main.js",
   "files": [
     "dist/**/*",
@@ -44,5 +44,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/palmetto/users"
   }
 }