@palmetto/users-sdk 0.1.0 → 0.2.0

package/dist/__generated__/schema.d.ts

@@ -28,7 +28,7 @@ export interface paths {
         delete?: never;
         options?: never;
         head?: never;
-        patch?: never;
+        patch: operations["UsersController_updateMe"];
         trace?: never;
     };
     "/api/users": {
@@ -38,7 +38,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        get: operations["UsersController_findAll"];
         put?: never;
         post: operations["UsersController_create"];
         delete?: never;
@@ -57,10 +57,10 @@ export interface paths {
         get: operations["UsersController_get"];
         put?: never;
         post?: never;
-        delete?: never;
+        delete: operations["UsersController_delete"];
         options?: never;
         head?: never;
-        patch?: never;
+        patch: operations["UsersController_update"];
         trace?: never;
     };
     "/api/users/{id}/token": {
@@ -79,6 +79,22 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/users/{id}/grants": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["UsersController_addGrant"];
+        delete: operations["UsersController_removeGrant"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/organizations/{id}": {
         parameters: {
             query?: never;
@@ -92,7 +108,7 @@ export interface paths {
         delete?: never;
         options?: never;
         head?: never;
-        patch?: never;
+        patch: operations["OrganizationsController_update"];
         trace?: never;
     };
     "/api/organizations": {
@@ -134,8 +150,10 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Get pending sign ups */
+        get: operations["SignUpsController_findAll"];
         put?: never;
+        /** Create Sign Up */
         post: operations["SignUpsController_create"];
         delete?: never;
         options?: never;
@@ -150,12 +168,14 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
+        /** Find Sign Up By Token */
         get: operations["SignUpsController_findOne"];
         put?: never;
         post?: never;
         delete?: never;
         options?: never;
         head?: never;
+        /** Update Sign Up By Token */
         patch: operations["SignUpsController_update"];
         trace?: never;
     };
@@ -168,6 +188,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
+        /** Create User By Sign Up Token */
         post: operations["SignUpsController_createUser"];
         delete?: never;
         options?: never;
@@ -175,6 +196,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/sign-ups/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Delete Sign Up */
+        delete: operations["SignUpsController_delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/search/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Search users */
+        post: operations["SearchUsersController_search"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -246,6 +301,24 @@ export interface components {
              */
             hasPAT: boolean;
         };
+        /** UpdateUser */
+        UpdateUserDto: {
+            /**
+             * @description First name
+             * @example John
+             */
+            firstName?: string;
+            /**
+             * @description Last name
+             * @example Doe
+             */
+            lastName?: string;
+            /**
+             * @description Phone number
+             * @example +18048675309
+             */
+            phoneNumber?: string;
+        };
         /** CreateUser */
         CreateUserDto: {
             /**
@@ -304,6 +377,19 @@ export interface components {
             /** @description Personal access token */
             personalAccessToken?: string;
         };
+        /** GrantInput */
+        GrantInputDto: {
+            /**
+             * @description Grant Entity
+             * @example photon:blueprint
+             */
+            entity: string;
+            /**
+             * @description Operation
+             * @example read
+             */
+            operation: string;
+        };
         /** Organization */
         OrganizationDto: {
             /** @example 66e25e72d10dfef2f9f6cc60 */
@@ -366,6 +452,14 @@ export interface components {
                 deny?: boolean;
             }[];
         };
+        /** UpdateOrganization */
+        UpdateOrganizationDto: {
+            /**
+             * @description Organization name
+             * @example Updated Organization Name
+             */
+            name: string;
+        };
         /** TokenInput */
         TokenInputDto: {
             /** @enum {string} */
@@ -389,11 +483,25 @@ export interface components {
             redirectUrl: string;
             /** @example 66e25e72d10dfef2f9f6cc60 */
             organizationId?: string;
+            firstName?: string;
+            lastName?: string;
+            /** Format: email */
+            email?: string;
         };
         /** SignUpToken */
         SignUpTokenDto: {
             token: string;
         };
+        /** SignUpAdmin */
+        SignUpAdminDto: {
+            id: string;
+            auth0Id?: string;
+            userId?: string;
+            organizationId?: string;
+            firstName?: string;
+            lastName?: string;
+            email?: string;
+        };
         /** SignUp */
         SignUpDto: {
             /** Format: uri */
@@ -401,6 +509,9 @@ export interface components {
             auth0Id?: string;
             userId?: string;
             organizationId?: string;
+            firstName?: string;
+            lastName?: string;
+            email?: string;
         };
         /** UpdateSignUp */
         UpdateSignUpDto: {
@@ -420,25 +531,152 @@ export interface components {
                 name: string;
             };
         };
-        /** Paging */
-        PagingDto: {
-            /** @description Limit of records per page */
-            limit: number;
-            /** @description Current page */
+        /** SearchUser */
+        SearchUserDto: {
+            /** @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: 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 User permissions
+             * @example {
+             *       "photon:blueprint": [
+             *         "read",
+             *         "write"
+             *       ]
+             *     }
+             */
+            permissions: {
+                [key: string]: string[];
+            };
+            /**
+             * @description Phone number
+             * @example +18048675309
+             */
+            phoneNumber: string;
+            /**
+             * @description Organization ID
+             * @example 66e3367b141b81fb54ec4e1f
+             */
+            organizationId: string;
+            /**
+             * @description Has Personal Access Token
+             * @example false
+             */
+            hasPAT: boolean;
+        };
+        /** SearchUsersInput */
+        SearchUsersInputDto: {
+            /** @default 1 */
             page: number;
-            /** @description Record count this page starts on */
-            pageStart: number;
-            /** @description Record count this page ends on */
-            pageEnd: number;
-            /** @description The count of records in total */
-            totalRecords: number;
-            /** @description The count of pages in total */
-            totalPages: number;
+            /** @default 10 */
+            limit: number;
+            /** @default  */
+            query: string;
+            /**
+             * @default []
+             * @example [
+             *       {
+             *         "filter": "organizationId",
+             *         "operation": {
+             *           "equals": "64d4f9994aaabec07646c9aa"
+             *         }
+             *       }
+             *     ]
+             */
+            filters: ({
+                /** @enum {string} */
+                filter: "organizationId";
+                operation: {
+                    equals: string;
+                    /** @default false */
+                    inverse: boolean;
+                } | {
+                    in: string[];
+                    /** @default false */
+                    inverse: boolean;
+                };
+            } | {
+                /** @enum {string} */
+                filter: "email";
+                operation: {
+                    equals: string;
+                    /** @default false */
+                    inverse: boolean;
+                };
+            } | {
+                /** @enum {string} */
+                filter: "firstName";
+                operation: {
+                    equals: string;
+                    /** @default false */
+                    inverse: boolean;
+                };
+            } | {
+                /** @enum {string} */
+                filter: "lastName";
+                operation: {
+                    equals: string;
+                    /** @default false */
+                    inverse: boolean;
+                };
+            })[];
         };
+        /** PaginatedList */
         PaginatedListDto: {
-            paging: components["schemas"]["PagingDto"];
+            data: unknown[];
+            paging: {
+                /** @description Limit of records per page */
+                limit: number;
+                /** @description Current page */
+                page: number;
+                /** @description Record count this page starts on */
+                pageStart: number;
+                /** @description Record count this page ends on */
+                pageEnd: number;
+                /** @description The count of records in total */
+                totalRecords: number;
+                /** @description The count of pages in total */
+                totalPages: number;
+            };
+        };
+        /** List */
+        ListDto: {
+            data: unknown[];
         };
-        ListDto: Record<string, never>;
         /** Grant */
         GrantDto: {
             /**
@@ -502,6 +740,55 @@ export interface operations {
             };
         };
     };
+    UsersController_updateMe: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateUserDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserDto"];
+                };
+            };
+        };
+    };
+    UsersController_findAll: {
+        parameters: {
+            query?: {
+                page?: number;
+                limit?: number;
+                /** @example 66e25e72d10dfef2f9f6cc60 */
+                organizationId?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["UserDto"][];
+                    } & components["schemas"]["PaginatedListDto"];
+                };
+            };
+        };
+    };
     UsersController_create: {
         parameters: {
             query?: never;
@@ -515,7 +802,7 @@ export interface operations {
             };
         };
         responses: {
-            200: {
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -546,7 +833,7 @@ export interface operations {
             };
         };
     };
-    UsersController_getPersonalAccessToken: {
+    UsersController_delete: {
         parameters: {
             query?: never;
             header?: never;
@@ -556,8 +843,52 @@ export interface operations {
             cookie?: never;
         };
         requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    UsersController_update: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateUserDto"];
+            };
+        };
         responses: {
             200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserDto"];
+                };
+            };
+        };
+    };
+    UsersController_getPersonalAccessToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -567,6 +898,56 @@ export interface operations {
             };
         };
     };
+    UsersController_addGrant: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GrantInputDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserDto"];
+                };
+            };
+        };
+    };
+    UsersController_removeGrant: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["GrantInputDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserDto"];
+                };
+            };
+        };
+    };
     OrganizationsController_getOrganization: {
         parameters: {
             query?: never;
@@ -588,6 +969,31 @@ export interface operations {
             };
         };
     };
+    OrganizationsController_update: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateOrganizationDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OrganizationDto"];
+                };
+            };
+        };
+    };
     OrganizationsController_create: {
         parameters: {
             query?: never;
@@ -634,6 +1040,32 @@ export interface operations {
             };
         };
     };
+    SignUpsController_findAll: {
+        parameters: {
+            query?: {
+                page?: number;
+                limit?: number;
+                /** @example 66e25e72d10dfef2f9f6cc60 */
+                organizationId?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["SignUpAdminDto"][];
+                    } & components["schemas"]["PaginatedListDto"];
+                };
+            };
+        };
+    };
     SignUpsController_create: {
         parameters: {
             query?: never;
@@ -728,4 +1160,49 @@ export interface operations {
             };
         };
     };
+    SignUpsController_delete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successfully removed */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    SearchUsersController_search: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SearchUsersInputDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["SearchUserDto"][];
+                    } & components["schemas"]["PaginatedListDto"];
+                };
+            };
+        };
+    };
 }

package/dist/__generated__/schema.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client.d.ts

@@ -1,5 +1,15 @@
-import { BaseSdkClient, RequestOptions } from "@palmetto/base-sdk-client";
+import { BaseSdkClient, CreateSdkClientInput, RequestOptions } from "@palmetto/base-sdk-client";
 import { paths } from "./__generated__/schema";
+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 GetUsersInput = NonNullable<paths["/api/users"]["get"]["parameters"]["query"]>;
+export type GetUsersResponse = paths["/api/users"]["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"];
@@ -10,6 +20,7 @@ export interface RefreshTokenInput {
     refreshToken: string;
 }
 export declare class UsersApiClient extends BaseSdkClient<paths> {
+    constructor(input: CreateSdkClientInput);
     me(opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
         id: string;
         meta: {
@@ -31,15 +42,99 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
     }> | import("@palmetto/result").ResultErr<{
         code: "UNKNOWN_ERROR";
     }>>;
+    updateMe(input: UpdateMeInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultOk<{
+        id: string;
+        meta: {
+            createdAt: string;
+            updatedAt?: string;
+        };
+        auth0Id: null;
+        email: string;
+        firstName: string;
+        lastName: string;
+        permissions: {
+            [key: string]: string[];
+        };
+        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"][];
+    } & {
+        data: unknown[];
+        paging: {
+            limit: number;
+            page: number;
+            pageStart: number;
+            pageEnd: number;
+            totalRecords: number;
+            totalPages: number;
+        };
+    }>>;
+    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<{
+        id: string;
+        meta: {
+            createdAt: string;
+            updatedAt?: string;
+        };
+        name: string;
+        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<{
+        id: string;
+        meta: {
+            createdAt: string;
+            updatedAt?: string;
+        };
+        name: string;
+        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<{
+        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<{
         redirectUrl: string;
         auth0Id?: string;
         userId?: string;
         organizationId?: string;
-    }> | import("@palmetto/result").ResultErr<{
-        code: "NOT_FOUND";
+        firstName?: string;
+        lastName?: string;
+        email?: string;
     }>>;
     createSignUpUser({ token, ...body }: CreateSignUpUserInput, opts?: RequestOptions): Promise<import("@palmetto/result").ResultErr<{
         code: "NOT_AUTHENTICATED";
@@ -50,6 +145,9 @@ export declare class UsersApiClient extends BaseSdkClient<paths> {
         auth0Id?: string;
         userId?: string;
         organizationId?: string;
+        firstName?: string;
+        lastName?: string;
+        email?: string;
     }> | import("@palmetto/result").ResultErr<{
         code: "INVALID_STATE";
     }>>;

package/dist/client.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -18,23 +19,124 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { BaseSdkClient } from "@palmetto/base-sdk-client";
-import { Ok, Err } from "@palmetto/result";
-export class UsersApiClient extends BaseSdkClient {
+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.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", {
                 headers: this.generateHeaders(opts),
             });
             if (data) {
-                return Ok(data);
+                return (0, result_1.Ok)(data);
             }
             switch (response.status) {
                 case 401:
                 case 404:
-                    return Err("NOT_AUTHENTICATED");
+                    return (0, result_1.Err)("NOT_AUTHENTICATED");
+                default:
+                    return (0, result_1.Err)("UNKNOWN_ERROR");
+            }
+        });
+    }
+    updateMe(input, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, 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");
+            }
+        });
+    }
+    getUsers(input, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, 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");
+            }
+        });
+    }
+    getOrganizationById(_a, opts_1) {
+        return __awaiter(this, arguments, void 0, function* ({ id }, opts) {
+            const { data, 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");
+            }
+        });
+    }
+    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}", {
+                params: {
+                    path: { id },
+                },
+                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");
+            }
+        });
+    }
+    createSignUp(input, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, 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 Err("UNKNOWN_ERROR");
+                    return (0, result_1.Err)("UNKNOWN_ERROR");
             }
         });
     }
@@ -45,13 +147,13 @@ export class UsersApiClient extends BaseSdkClient {
                 headers: this.generateHeaders(opts),
             });
             if (data) {
-                return Ok(data);
+                return (0, result_1.Ok)(data);
             }
             switch (response.status) {
                 case 404:
-                    return Err("NOT_FOUND");
+                    return (0, result_1.Err)("NOT_FOUND");
                 default:
-                    return Err("UNKNOWN_ERROR");
+                    return (0, result_1.Err)("UNKNOWN_ERROR");
             }
         });
     }
@@ -64,15 +166,15 @@ export class UsersApiClient extends BaseSdkClient {
                 body,
             });
             if (data) {
-                return Ok(data);
+                return (0, result_1.Ok)(data);
             }
             switch (response.status) {
                 case 401:
-                    return Err("NOT_AUTHENTICATED");
+                    return (0, result_1.Err)("NOT_AUTHENTICATED");
                 case 409:
-                    return Err("INVALID_STATE");
+                    return (0, result_1.Err)("INVALID_STATE");
                 default:
-                    return Err("UNKNOWN_ERROR");
+                    return (0, result_1.Err)("UNKNOWN_ERROR");
             }
         });
     }
@@ -96,7 +198,7 @@ export class UsersApiClient extends BaseSdkClient {
                 body: input,
             });
             if (data) {
-                return Ok({
+                return (0, result_1.Ok)({
                     accessToken: data.access_token,
                     idToken: data.id_token,
                     refreshToken: data.refresh_token,
@@ -105,8 +207,9 @@ export class UsersApiClient extends BaseSdkClient {
             }
             switch (response.status) {
                 default:
-                    return Err("UNKNOWN_ERROR");
+                    return (0, result_1.Err)("UNKNOWN_ERROR");
             }
         });
     }
 }
+exports.UsersApiClient = UsersApiClient;

package/dist/main.d.ts

@@ -1 +1,2 @@
 export * from "./client";
+export { type RequestOptions } from "@palmetto/base-sdk-client";

package/dist/main.js

@@ -1 +1,17 @@
-export * from "./client";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palmetto/users-sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "main": "./dist/main.js",
   "files": [
     "dist/**/*",
@@ -13,6 +13,7 @@
     "lint": "eslint . --fix --cache",
     "format": "prettier --write \"src/**/*.ts\"",
     "tc": "tsc --noEmit",
+    "start:dev": "tsc --watch",
     "build": "tsc",
     "generate": "node ./scripts/generateApiSchema.mjs",
     "prepublishOnly": "yarn build",
@@ -33,8 +34,8 @@
     "typescript": "5.5.4"
   },
   "dependencies": {
-    "@palmetto/base-sdk-client": "^0.0.2",
-    "@palmetto/result": "^1.0.1",
+    "@palmetto/base-sdk-client": "1.1.0",
+    "@palmetto/result": "1.2.0",
     "openapi-fetch": "^0.12.2"
   },
   "publishConfig": {

package/dist/base-client.d.ts

@@ -1,18 +0,0 @@
-import { Client, Middleware } from "openapi-fetch";
-export interface CreateClientOptions {
-    apiUrl: string;
-    authToken?: string;
-}
-export interface ApiOptions {
-    authToken?: string;
-    headers?: Record<string, string>;
-}
-export declare class BaseClient<TPaths extends object> {
-    protected client: Client<TPaths, `${string}/${string}`>;
-    protected headers: Headers;
-    constructor(opts: CreateClientOptions);
-    setAuthToken(authToken: string): void;
-    use(...middleware: Middleware[]): void;
-    protected generateHeaders(opts?: ApiOptions): Headers;
-    protected mergeHeaders(overrides: Record<string, string>): Headers;
-}

package/dist/base-client.js

@@ -1,32 +0,0 @@
-import createClient from "openapi-fetch";
-export class BaseClient {
-    constructor(opts) {
-        this.client = createClient({ baseUrl: opts.apiUrl });
-        this.headers = new Headers();
-        if (opts.authToken) {
-            this.setAuthToken(opts.authToken);
-        }
-    }
-    setAuthToken(authToken) {
-        this.headers.set("Authorization", `Bearer ${authToken}`);
-    }
-    use(...middleware) {
-        this.client.use(...middleware);
-    }
-    generateHeaders(opts) {
-        const headers = (opts === null || opts === void 0 ? void 0 : opts.headers)
-            ? this.mergeHeaders(opts.headers)
-            : new Headers(this.headers);
-        if (opts === null || opts === void 0 ? void 0 : opts.authToken) {
-            headers.set("Authorization", `Bearer ${opts.authToken}`);
-        }
-        return headers;
-    }
-    mergeHeaders(overrides) {
-        const merged = new Headers(this.headers);
-        for (const key in overrides) {
-            merged.set(key, overrides[key]);
-        }
-        return merged;
-    }
-}

package/dist/result.d.ts

@@ -1,19 +0,0 @@
-export interface ResultOk<TData = unknown> {
-    ok: true;
-    data: TData;
-}
-export interface ResultErr<TError = unknown> {
-    ok: false;
-    error: TError;
-}
-export type Result<TData = unknown, TError = unknown> = ResultOk<TData> | ResultErr<TError>;
-export type InferResultData<TResult extends Result> = TResult extends ResultOk<infer TData> ? TData : never;
-export type InferResultError<TResult extends Result> = TResult extends ResultErr<infer TError> ? TError : never;
-export declare function Err<TCode extends string>(code: TCode): ResultErr<{
-    code: TCode;
-}>;
-export declare function Err<TCode extends string, TExtra extends Record<string, unknown>>(code: TCode, extra: TExtra): ResultErr<TExtra & {
-    code: TCode;
-}>;
-export declare function Ok<TData = unknown>(data: TData): ResultOk<TData>;
-export declare function assertOk(result: Result): asserts result is ResultOk;

package/dist/result.js

@@ -1,11 +0,0 @@
-export function Err(code, extra) {
-    return { ok: false, error: Object.assign(Object.assign({}, extra), { code }) };
-}
-export function Ok(data) {
-    return { ok: true, data };
-}
-export function assertOk(result) {
-    if (!result.ok) {
-        throw new Error("Result was an error!");
-    }
-}