@palmetto/users-sdk 0.2.1 → 1.1.0

package/dist/__generated__/schema.d.ts

@@ -164,10 +164,10 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Get pending sign ups */
+        /** Get pending sign-ups */
         get: operations["SignUpsController_findAll"];
         put?: never;
-        /** Create Sign Up */
+        /** Create sign-up */
         post: operations["SignUpsController_create"];
         delete?: never;
         options?: never;
@@ -182,15 +182,14 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Find Sign Up By Token */
+        /** Find sign-up */
         get: operations["SignUpsController_findOne"];
         put?: never;
         post?: never;
         delete?: never;
         options?: never;
         head?: never;
-        /** Update Sign Up By Token */
-        patch: operations["SignUpsController_update"];
+        patch?: never;
         trace?: never;
     };
     "/api/sign-ups/{token}/user": {
@@ -202,7 +201,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Create User By Sign Up Token */
+        /** Create user with sign-up token */
         post: operations["SignUpsController_createUser"];
         delete?: never;
         options?: never;
@@ -220,7 +219,7 @@ export interface paths {
         get?: never;
         put?: never;
         post?: never;
-        /** Delete Sign Up */
+        /** Delete sign-up */
         delete: operations["SignUpsController_delete"];
         options?: never;
         head?: never;
@@ -370,16 +369,16 @@ export interface components {
         /** BadRequestError */
         BadRequestErrorDto: {
             /**
-             * @example InternalServerError
+             * @example BadRequest
              * @enum {string}
              */
-            error: "InternalServerError";
+            error: "BadRequest";
             /**
-             * @example 500
+             * @example 400
              * @enum {number}
              */
-            statusCode: 500;
-            /** @example An unexpected service error occurred */
+            statusCode: 400;
+            /** @example Request is invalid */
             message: string;
             /** @example Technical error description */
             reason: string;
@@ -413,6 +412,61 @@ export interface components {
                 totalPages: number;
             };
         };
+        /** ListUser */
+        ListUserDto: {
+            /** @example 66e25e72d10dfef2f9f6cc60 */
+            id: string;
+            meta: {
+                /**
+                 * Format: date-time
+                 * @description Created at timestamp
+                 * @example 2024-09-11T00:09:06.276+0000
+                 */
+                createdAt: string;
+                /**
+                 * Format: date-time
+                 * @description Updated at timestamp
+                 * @example 2024-09-11T00:09:06.276+0000
+                 */
+                updatedAt?: string;
+            };
+            /**
+             * @description Auth0 ID
+             * @example auth0|1234567890
+             */
+            auth0Id: string | null;
+            /**
+             * Format: email
+             * @description Email
+             * @example test@test.com
+             */
+            email: string;
+            /**
+             * @description First name
+             * @example John
+             */
+            firstName: string;
+            /**
+             * @description Last name
+             * @example Doe
+             */
+            lastName: string;
+            /**
+             * @description Phone number
+             * @example +18048675309
+             */
+            phoneNumber: string;
+            /**
+             * @description Organization ID
+             * @example 66e3367b141b81fb54ec4e1f
+             */
+            organizationId: string;
+            /**
+             * @description Has Personal Access Token
+             * @example false
+             */
+            hasPAT: boolean;
+        };
         /** CreateUser */
         CreateUserDto: {
             /**
@@ -443,7 +497,8 @@ export interface components {
             phoneNumber: string;
             /** @example 66e25e72d10dfef2f9f6cc60 */
             organizationId: string;
-            grants?: {
+            /** @default [] */
+            grants: {
                 /**
                  * @description Grant Entity
                  * @example photon:blueprint
@@ -561,8 +616,11 @@ export interface components {
              * @example Organization Name
              */
             name: string;
-            /** @description Grants */
-            grants?: {
+            /**
+             * @description Grants
+             * @default []
+             */
+            grants: {
                 /**
                  * @description Grant Entity
                  * @example photon:blueprint
@@ -629,6 +687,8 @@ export interface components {
             firstName?: string;
             lastName?: string;
             email?: string;
+            /** Format: date-time */
+            expiresAt: string;
         };
         /** SignUp */
         SignUpDto: {
@@ -640,11 +700,8 @@ export interface components {
             firstName?: string;
             lastName?: string;
             email?: string;
-        };
-        /** UpdateSignUp */
-        UpdateSignUpDto: {
-            /** @example auth0|6fexxxxxxxxxxxxxxxx */
-            auth0Id: string;
+            /** Format: date-time */
+            expiresAt: string;
         };
         /** CreateSignUp */
         CreateSignUpUserDto: {
@@ -698,18 +755,6 @@ export interface components {
              * @example Doe
              */
             lastName: string;
-            /**
-             * @description User permissions
-             * @example {
-             *       "photon:blueprint": [
-             *         "read",
-             *         "write"
-             *       ]
-             *     }
-             */
-            permissions: {
-                [key: string]: string[];
-            };
             /**
              * @description Phone number
              * @example +18048675309
@@ -916,7 +961,7 @@ export interface operations {
                 };
                 content: {
                     "application/json": {
-                        data: components["schemas"]["UserDto"][];
+                        data: components["schemas"]["ListUserDto"][];
                     } & components["schemas"]["PaginatedListDto"];
                 };
             };
@@ -1702,7 +1747,7 @@ export interface operations {
             };
         };
     };
-    SignUpsController_update: {
+    SignUpsController_createUser: {
         parameters: {
             query?: never;
             header?: never;
@@ -1713,7 +1758,7 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["UpdateSignUpDto"];
+                "application/json": components["schemas"]["CreateSignUpUserDto"];
             };
         };
         responses: {
@@ -1734,56 +1779,13 @@ export interface operations {
                     "application/json": components["schemas"]["BadRequestErrorDto"];
                 };
             };
-            /** @description When the sign up is not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["NotFoundErrorDto"];
-                };
-            };
-            /** @description When the sign up token already has an auth0Id */
-            409: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ConflictErrorDto"];
-                };
-            };
-        };
-    };
-    SignUpsController_createUser: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                token: string;
-            };
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["CreateSignUpUserDto"];
-            };
-        };
-        responses: {
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["SignUpDto"];
-                };
-            };
-            /** @description When the sign up token or body is invalid */
-            400: {
+            /** @description When authentication fails */
+            401: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["BadRequestErrorDto"];
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
                 };
             };
             /** @description When the sign up is not found */

package/dist/client.d.ts

@@ -1,29 +1,5 @@
-import { BaseSdkClient, CreateSdkClientInput, RequestOptions } from "@palmetto/base-sdk-client";
+import { ApiInput, ApiResponse, BaseSdkClient, CreateSdkClientInput, RequestOptions } from "@palmetto/base-sdk-client";
 import { paths } from "./__generated__/schema";
-export type MeResponse = paths["/api/users/me"]["get"]["responses"]["200"]["content"]["application/json"];
-export type UpdateMeInput = paths["/api/users/me"]["patch"]["requestBody"]["content"]["application/json"];
-export type UpdateMeResponse = paths["/api/users/me"]["patch"]["responses"]["200"]["content"]["application/json"];
-export type UpdateUserByIdInput = paths["/api/users/{id}"]["patch"]["parameters"]["path"] & paths["/api/users/{id}"]["patch"]["requestBody"]["content"]["application/json"];
-export type UpdateUserByIdResponse = paths["/api/users/{id}"]["patch"]["responses"]["200"]["content"]["application/json"];
-export type GetUsersInput = NonNullable<paths["/api/users"]["get"]["parameters"]["query"]>;
-export type GetUsersResponse = paths["/api/users"]["get"]["responses"]["200"]["content"]["application/json"];
-export type GetUserByIdInput = paths["/api/users/{id}"]["get"]["parameters"]["path"];
-export type GetUserByIdResponse = paths["/api/users/{id}"]["get"]["responses"]["200"]["content"]["application/json"];
-export type GetOrganizationInput = paths["/api/organizations/{id}"]["get"]["parameters"]["path"];
-export type GetOrganizationResponse = paths["/api/organizations/{id}"]["get"]["responses"]["200"]["content"]["application/json"];
-export type UpdateOrganizationInput = paths["/api/organizations/{id}"]["patch"]["parameters"]["path"] & paths["/api/organizations/{id}"]["patch"]["requestBody"]["content"]["application/json"];
-export type UpdateOrganizationResponse = paths["/api/organizations/{id}"]["patch"]["responses"]["200"]["content"]["application/json"];
-export type CreateSignUpInput = paths["/api/sign-ups"]["post"]["requestBody"]["content"]["application/json"];
-export type CreateSignUpResponse = paths["/api/sign-ups"]["post"]["responses"]["200"]["content"]["application/json"];
-export type GetSignUpInput = paths["/api/sign-ups/{token}"]["get"]["parameters"]["path"];
-export type GetSignUpResponse = paths["/api/sign-ups/{token}"]["get"]["responses"]["200"]["content"]["application/json"];
-export type CreateSignUpUserInput = paths["/api/sign-ups/{token}/user"]["post"]["parameters"]["path"] & paths["/api/sign-ups/{token}/user"]["post"]["requestBody"]["content"]["application/json"];
-export interface GetAuthTokenInput {
-    code: string;
-}
-export interface RefreshTokenInput {
-    refreshToken: string;
-}
 export declare class UsersApiClient extends BaseSdkClient<paths> {
     constructor(input: CreateSdkClientInput);
     me(opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
@@ -42,11 +18,32 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         phoneNumber: string;
         organizationId: string;
         hasPAT: boolean;
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_AUTHENTICATED";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }>>;
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UserDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
     updateMe(input: UpdateMeInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         id: string;
         meta: {
@@ -63,14 +60,41 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         phoneNumber: string;
         organizationId: string;
         hasPAT: boolean;
-    }> | import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "BAD_REQUEST";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_FOUND";
-    }>>;
-    updateUserById({ id, ...input }: UpdateUserByIdInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UserDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    updateUser({ id, ...input }: UpdateUserInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         id: string;
         meta: {
             createdAt: string;
@@ -86,19 +110,50 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         phoneNumber: string;
         organizationId: string;
         hasPAT: boolean;
-    }> | import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "BAD_REQUEST";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_FOUND";
-    }>>;
-    getUsers(input: GetUsersInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "BAD_REQUEST";
-    }> | import("@palmetto/result").ResultOk<{
-        data: import("./__generated__/schema").components["schemas"]["UserDto"][];
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UserDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["NotFoundErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    getUsers(input: GetUsersInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
+        data: import("./__generated__/schema").components["schemas"]["ListUserDto"][];
     } & {
         data: unknown[];
         paging: {
@@ -109,8 +164,43 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
             totalRecords: number;
             totalPages: number;
         };
-    }>>;
-    getUserById({ id }: GetUserByIdInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    data: import("./__generated__/schema").components["schemas"]["ListUserDto"][];
+                } & import("./__generated__/schema").components["schemas"]["PaginatedListDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    getUser({ id }: GetUserInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         id: string;
         meta: {
             createdAt: string;
@@ -126,20 +216,49 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         phoneNumber: string;
         organizationId: string;
         hasPAT: boolean;
-    }> | import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "BAD_REQUEST";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_FOUND";
-    }>>;
-    getOrganizationById({ id }: GetOrganizationInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "BAD_REQUEST";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_FOUND";
-    }> | import("@palmetto/result").ResultOk<{
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UserDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["NotFoundErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    getOrganization({ id }: GetOrganizationInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         id: string;
         meta: {
             createdAt: string;
@@ -149,14 +268,49 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         permissions: {
             [key: string]: string[];
         };
-    }>>;
-    updateOrganization({ id, ...input }: UpdateOrganizationInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "BAD_REQUEST";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_FOUND";
-    }> | import("@palmetto/result").ResultOk<{
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["OrganizationDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["NotFoundErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    updateOrganization({ id, ...input }: UpdateOrganizationInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         id: string;
         meta: {
             createdAt: string;
@@ -166,19 +320,77 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         permissions: {
             [key: string]: string[];
         };
-    }>>;
-    createSignUp(input: CreateSignUpInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "BAD_REQUEST";
-    }> | import("@palmetto/result").ResultOk<{
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["OrganizationDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["NotFoundErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    createSignUp(input: CreateSignUpInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         token: string;
-    }>>;
-    getSignUp({ token }: GetSignUpInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_FOUND";
-    }> | import("@palmetto/result").ResultOk<{
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["SignUpTokenDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    getSignUp({ token }: GetSignUpInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         redirectUrl: string;
         auth0Id?: string;
         userId?: string;
@@ -186,12 +398,82 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         firstName?: string;
         lastName?: string;
         email?: string;
-    }>>;
-    createSignUpUser({ token, ...body }: CreateSignUpUserInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "NOT_AUTHENTICATED";
-    }> | import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultOk<{
+        expiresAt: string;
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["SignUpDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["NotFoundErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    getSignUps(input: GetSignUpsInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
+        data: import("./__generated__/schema").components["schemas"]["SignUpAdminDto"][];
+    } & {
+        data: unknown[];
+        paging: {
+            limit: number;
+            page: number;
+            pageStart: number;
+            pageEnd: number;
+            totalRecords: number;
+            totalPages: number;
+        };
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    data: import("./__generated__/schema").components["schemas"]["SignUpAdminDto"][];
+                } & import("./__generated__/schema").components["schemas"]["PaginatedListDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ForbiddenErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    createSignUpUser({ token, ...body }: CreateSignUpUserInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         redirectUrl: string;
         auth0Id?: string;
         userId?: string;
@@ -199,24 +481,109 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         firstName?: string;
         lastName?: string;
         email?: string;
-    }> | import("@palmetto/result").ResultErr<{
-        code: "INVALID_STATE";
-    }>>;
-    getAuthToken({ code }: GetAuthTokenInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultOk<{
+        expiresAt: string;
+    }> | import("@palmetto/base-sdk-client").SdkError<import("openapi-typescript-helpers").ErrorResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["SignUpDto"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["BadRequestErrorDto"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["UnauthorizedErrorDto"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["NotFoundErrorDto"];
+            };
+        };
+        409: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./__generated__/schema").components["schemas"]["ConflictErrorDto"];
+            };
+        };
+    }, `${string}/${string}`>>>;
+    getAuthToken({ code }: GetAuthTokenInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         accessToken: string;
         idToken: string;
         refreshToken: string;
         expiresIn: number;
+    }> | import("@palmetto/base-sdk-client").SdkError<{
+        error: "BadRequest";
+        statusCode: 400;
+        message: string;
+        reason: string;
+        validations: {
+            [key: string]: string[];
+        };
     }>>;
-    refreshToken({ refreshToken }: RefreshTokenInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
-        code: "UNKNOWN_ERROR";
-    }> | import("@palmetto/result").ResultOk<{
+    refreshToken({ refreshToken }: RefreshTokenInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         accessToken: string;
         idToken: string;
         refreshToken: string;
         expiresIn: number;
+    }> | import("@palmetto/base-sdk-client").SdkError<{
+        error: "BadRequest";
+        statusCode: 400;
+        message: string;
+        reason: string;
+        validations: {
+            [key: string]: string[];
+        };
     }>>;
     private getToken;
 }
+export type MeResponse = ApiResponse<paths["/api/users/me"]["get"]>;
+export type UpdateMeInput = ApiInput<paths["/api/users/me"]["patch"]>;
+export type UpdateMeResponse = ApiResponse<paths["/api/users/me"]["patch"]>;
+export type UpdateUserInput = ApiInput<paths["/api/users/{id}"]["patch"]>;
+export type UpdateUserResponse = ApiResponse<paths["/api/users/{id}"]["patch"]>;
+export type GetUsersInput = NonNullable<ApiInput<paths["/api/users"]["get"]>>;
+export type GetUsersResponse = ApiResponse<paths["/api/users"]["get"]>;
+export type GetSignUpsInput = ApiInput<paths["/api/sign-ups"]["get"]>;
+export type GetSignUpsResponse = ApiResponse<paths["/api/sign-ups"]["get"]>;
+export type GetUserInput = ApiInput<paths["/api/users/{id}"]["get"]>;
+export type GetUserResponse = ApiResponse<paths["/api/users/{id}"]["get"]>;
+export type GetOrganizationInput = ApiInput<paths["/api/organizations/{id}"]["get"]>;
+export type GetOrganizationResponse = ApiResponse<paths["/api/organizations/{id}"]["get"]>;
+export type UpdateOrganizationInput = ApiInput<paths["/api/organizations/{id}"]["patch"]>;
+export type UpdateOrganizationResponse = ApiResponse<paths["/api/organizations/{id}"]["patch"]>;
+export type CreateSignUpInput = ApiInput<paths["/api/sign-ups"]["post"]>;
+export type CreateSignUpResponse = ApiResponse<paths["/api/sign-ups"]["post"]>;
+export type GetSignUpInput = ApiInput<paths["/api/sign-ups/{token}"]["get"]>;
+export type GetSignUpResponse = ApiResponse<paths["/api/sign-ups/{token}"]["get"]>;
+export type CreateSignUpUserInput = ApiInput<paths["/api/sign-ups/{token}/user"]["post"]>;
+export type CreateSignUpUserResponse = ApiResponse<paths["/api/sign-ups/{token}/user"]["post"]>;
+export interface GetAuthTokenInput {
+    code: string;
+}
+export interface RefreshTokenInput {
+    refreshToken: string;
+}
+export interface GetTokenResponse {
+    accessToken: string;
+    idToken: string;
+    refreshToken: string;
+    expiresIn: number;
+}

package/dist/client.js

@@ -23,51 +23,38 @@ 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/0.2.1";
+const SDK_VERSION_SLUG = "palmetto-users-sdk/1.0.0";
 class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
     constructor(input) {
         super(Object.assign(Object.assign({}, input), { sdkVersion: SDK_VERSION_SLUG }));
     }
     me(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data, response } = yield this.client.GET("/api/users/me", {
+            const { data, error, response } = yield this.client.GET("/api/users/me", {
                 headers: this.generateHeaders(opts),
             });
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 401:
-                case 404:
-                    return (0, result_1.Err)("NOT_AUTHENTICATED");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
     updateMe(input, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data, response } = yield this.client.PATCH("/api/users/me", {
+            const { data, error, response } = yield this.client.PATCH("/api/users/me", {
                 body: input,
                 headers: this.generateHeaders(opts),
             });
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 400:
-                    return (0, result_1.Err)("BAD_REQUEST");
-                case 404:
-                    return (0, result_1.Err)("NOT_FOUND");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
-    updateUserById(_a, opts) {
+    updateUser(_a, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             var { id } = _a, input = __rest(_a, ["id"]);
-            const { data, response } = yield this.client.PATCH("/api/users/{id}", {
+            const { data, error, response } = yield this.client.PATCH("/api/users/{id}", {
                 params: { path: { id } },
                 body: input,
                 headers: this.generateHeaders(opts),
@@ -75,75 +62,49 @@ class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 400:
-                    return (0, result_1.Err)("BAD_REQUEST");
-                case 404:
-                    return (0, result_1.Err)("NOT_FOUND");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
     getUsers(input, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data, response } = yield this.client.GET("/api/users", {
+            const { data, error, response } = yield this.client.GET("/api/users", {
                 params: { query: input },
                 headers: this.generateHeaders(opts),
             });
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 400:
-                    return (0, result_1.Err)("BAD_REQUEST");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
-    getUserById(_a, opts_1) {
+    getUser(_a, opts_1) {
         return __awaiter(this, arguments, void 0, function* ({ id }, opts) {
-            const { data, response } = yield this.client.GET("/api/users/{id}", {
+            const { data, error, response } = yield this.client.GET("/api/users/{id}", {
                 params: { path: { id } },
                 headers: this.generateHeaders(opts),
             });
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 400:
-                    return (0, result_1.Err)("BAD_REQUEST");
-                case 404:
-                    return (0, result_1.Err)("NOT_FOUND");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
-    getOrganizationById(_a, opts_1) {
+    getOrganization(_a, opts_1) {
         return __awaiter(this, arguments, void 0, function* ({ id }, opts) {
-            const { data, response } = yield this.client.GET("/api/organizations/{id}", {
+            const { data, error, response } = yield this.client.GET("/api/organizations/{id}", {
                 params: { path: { id } },
                 headers: this.generateHeaders(opts),
             });
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 400:
-                    return (0, result_1.Err)("BAD_REQUEST");
-                case 404:
-                    return (0, result_1.Err)("NOT_FOUND");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
     updateOrganization(_a, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             var { id } = _a, input = __rest(_a, ["id"]);
-            const { data, response } = yield this.client.PATCH("/api/organizations/{id}", {
+            const { data, error, response } = yield this.client.PATCH("/api/organizations/{id}", {
                 params: {
                     path: { id },
                 },
@@ -153,54 +114,49 @@ class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 400:
-                    return (0, result_1.Err)("BAD_REQUEST");
-                case 404:
-                    return (0, result_1.Err)("NOT_FOUND");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
     createSignUp(input, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data, response } = yield this.client.POST("/api/sign-ups", {
+            const { data, error, response } = yield this.client.POST("/api/sign-ups", {
                 body: input,
                 headers: this.generateHeaders(opts),
             });
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 400:
-                    return (0, result_1.Err)("BAD_REQUEST");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
     getSignUp(_a, opts_1) {
         return __awaiter(this, arguments, void 0, function* ({ token }, opts) {
-            const { data, response } = yield this.client.GET("/api/sign-ups/{token}", {
+            const { data, error, response } = yield this.client.GET("/api/sign-ups/{token}", {
                 params: { path: { token } },
                 headers: this.generateHeaders(opts),
             });
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 404:
-                    return (0, result_1.Err)("NOT_FOUND");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
+            return this.handleErrorResponse(error, response);
+        });
+    }
+    getSignUps(input, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error, response } = yield this.client.GET("/api/sign-ups", {
+                params: { query: input },
+                headers: this.generateHeaders(opts),
+            });
+            if (data) {
+                return (0, result_1.Ok)(data);
             }
+            return this.handleErrorResponse(error, response);
         });
     }
     createSignUpUser(_a, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             var { token } = _a, body = __rest(_a, ["token"]);
-            const { data, response } = yield this.client.POST("/api/sign-ups/{token}/user", {
+            const { data, error, response } = yield this.client.POST("/api/sign-ups/{token}/user", {
                 headers: this.generateHeaders(opts),
                 params: { path: { token } },
                 body,
@@ -208,14 +164,7 @@ class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
             if (data) {
                 return (0, result_1.Ok)(data);
             }
-            switch (response.status) {
-                case 401:
-                    return (0, result_1.Err)("NOT_AUTHENTICATED");
-                case 409:
-                    return (0, result_1.Err)("INVALID_STATE");
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
     getAuthToken(_a, opts_1) {
@@ -233,7 +182,7 @@ class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
     }
     getToken(input, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data, response } = yield this.client.POST("/api/auth/token", {
+            const { data, error, response } = yield this.client.POST("/api/auth/token", {
                 headers: this.generateHeaders(opts),
                 body: input,
             });
@@ -245,10 +194,7 @@ class UsersApiClient extends base_sdk_client_1.BaseSdkClient {
                     expiresIn: data.expires_in,
                 });
             }
-            switch (response.status) {
-                default:
-                    return (0, result_1.Err)("UNKNOWN_ERROR");
-            }
+            return this.handleErrorResponse(error, response);
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palmetto/users-sdk",
-  "version": "0.2.1",
+  "version": "1.1.0",
   "main": "./dist/main.js",
   "files": [
     "dist/**/*",
@@ -34,9 +34,10 @@
     "typescript": "5.5.4"
   },
   "dependencies": {
-    "@palmetto/base-sdk-client": "1.1.0",
-    "@palmetto/result": "1.2.0",
-    "openapi-fetch": "^0.12.2"
+    "@palmetto/base-sdk-client": "^1.1.0",
+    "@palmetto/result": "^1.2.0",
+    "openapi-fetch": "^0.12.2",
+    "openapi-typescript-helpers": "^0.0.15"
   },
   "publishConfig": {
     "access": "public"