@palmetto/users-sdk 0.0.12 → 0.0.13

package/dist/__generated__/schema.d.ts

@@ -0,0 +1,731 @@
+export interface paths {
+    "/api/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["HealthController_getHealth"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/users/me": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["UsersController_getMe"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["UsersController_create"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/users/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["UsersController_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/users/{id}/token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["UsersController_getPersonalAccessToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/organizations/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["OrganizationsController_getOrganization"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/organizations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["OrganizationsController_create"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/auth/token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["AuthController_generateToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sign-ups": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["SignUpsController_create"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sign-ups/{token}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["SignUpsController_findOne"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch: operations["SignUpsController_update"];
+        trace?: never;
+    };
+    "/api/sign-ups/{token}/user": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["SignUpsController_createUser"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /** User */
+        UserDto: {
+            /** @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;
+        };
+        /** CreateUser */
+        CreateUserDto: {
+            /**
+             * @description Auth0 ID
+             * @example auth0|1234567890
+             */
+            auth0Id: string;
+            /**
+             * 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;
+            /** @example 66e25e72d10dfef2f9f6cc60 */
+            organizationId: string;
+            grants?: {
+                /**
+                 * @description Grant Entity
+                 * @example photon:blueprint
+                 */
+                entity: string;
+                /**
+                 * @description Operation
+                 * @example read
+                 */
+                operation: string;
+                /**
+                 * @description Deny
+                 * @example false
+                 */
+                deny?: boolean;
+            }[];
+        };
+        /** User Personal Access Token */
+        UserPersonalAccessTokenDto: {
+            /**
+             * @description User ID
+             * @example 66e3367b141b81fb54ec4e1f
+             */
+            id: string;
+            /** @description Personal access token */
+            personalAccessToken?: string;
+        };
+        /** Organization */
+        OrganizationDto: {
+            /** @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 Name
+             * @example Palmetto
+             */
+            name: string;
+            /**
+             * @description Organization permissions
+             * @example {
+             *       "photon:blueprint": [
+             *         "read",
+             *         "write"
+             *       ]
+             *     }
+             */
+            permissions: {
+                [key: string]: string[];
+            };
+        };
+        /** CreateOrganization */
+        CreateOrganizationDto: {
+            /**
+             * @description Name
+             * @example Organization Name
+             */
+            name: string;
+            /** @description Grants */
+            grants?: {
+                /**
+                 * @description Grant Entity
+                 * @example photon:blueprint
+                 */
+                entity: string;
+                /**
+                 * @description Operation
+                 * @example read
+                 */
+                operation: string;
+                /**
+                 * @description Deny
+                 * @example false
+                 */
+                deny?: boolean;
+            }[];
+        };
+        /** TokenInput */
+        TokenInputDto: {
+            /** @enum {string} */
+            grant_type: "authorization_code";
+            code: string;
+        } | {
+            /** @enum {string} */
+            grant_type: "refresh_token";
+            refresh_token: string;
+        };
+        /** TokenResponse */
+        TokenResponseDto: {
+            access_token: string;
+            id_token: string;
+            refresh_token: string;
+            expires_in: number;
+        };
+        /** CreateSignUp */
+        CreateSignUpDto: {
+            /** Format: uri */
+            redirectUrl: string;
+            /** @example 66e25e72d10dfef2f9f6cc60 */
+            organizationId?: string;
+        };
+        /** SignUpToken */
+        SignUpTokenDto: {
+            token: string;
+        };
+        /** SignUp */
+        SignUpDto: {
+            /** Format: uri */
+            redirectUrl: string;
+            auth0Id?: string;
+            userId?: string;
+            organizationId?: string;
+        };
+        /** UpdateSignUp */
+        UpdateSignUpDto: {
+            /** @example auth0|6fexxxxxxxxxxxxxxxx */
+            auth0Id: string;
+        };
+        /** CreateSignUp */
+        CreateSignUpUserDto: {
+            /** @example John */
+            firstName: string;
+            /** @example Smith */
+            lastName: string;
+            /** @example +13015558080 */
+            phoneNumber: string;
+            organization?: {
+                /** @example My Organization */
+                name: string;
+            };
+        };
+        /** Paging */
+        PagingDto: {
+            /** @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;
+        };
+        PaginatedListDto: {
+            paging: components["schemas"]["PagingDto"];
+        };
+        ListDto: Record<string, never>;
+        /** Grant */
+        GrantDto: {
+            /**
+             * @description Grant entity
+             * @example photon:tasks
+             */
+            entity: string;
+            /**
+             * @description Grant operation
+             * @example read
+             */
+            operation: string;
+            /**
+             * @description Deny grant
+             * @example false
+             */
+            deny?: boolean;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    HealthController_getHealth: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    UsersController_getMe: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserDto"];
+                };
+            };
+        };
+    };
+    UsersController_create: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateUserDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserDto"];
+                };
+            };
+        };
+    };
+    UsersController_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        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: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserPersonalAccessTokenDto"];
+                };
+            };
+        };
+    };
+    OrganizationsController_getOrganization: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OrganizationDto"];
+                };
+            };
+        };
+    };
+    OrganizationsController_create: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateOrganizationDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OrganizationDto"];
+                };
+            };
+        };
+    };
+    AuthController_generateToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["TokenInputDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TokenResponseDto"];
+                };
+            };
+        };
+    };
+    SignUpsController_create: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateSignUpDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SignUpTokenDto"];
+                };
+            };
+        };
+    };
+    SignUpsController_findOne: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                token: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SignUpDto"];
+                };
+            };
+        };
+    };
+    SignUpsController_update: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                token: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateSignUpDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SignUpDto"];
+                };
+            };
+        };
+    };
+    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"];
+                };
+            };
+        };
+    };
+}

package/dist/__generated__/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/base-client.d.ts

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,32 @@
+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/client.d.ts

@@ -1,22 +1,23 @@
-import { Middleware } from "openapi-fetch";
-export interface CreateClientOptions {
-    apiUrl: string;
-    authToken?: string;
+import { paths } from "./__generated__/schema";
+import { ApiOptions, BaseClient } from "./base-client";
+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 ApiOptions {
-    authToken?: string;
-    headers?: Record<string, string>;
+export interface RefreshTokenInput {
+    refreshToken: string;
 }
-export declare class UsersApiClient {
-    private client;
-    private headers;
-    constructor(opts: CreateClientOptions);
-    setAuthToken(authToken: string): void;
-    use(...middleware: Middleware[]): void;
+export declare class UsersApiClient extends BaseClient<paths> {
     me(opts?: ApiOptions): Promise<import("./result").ResultOk<{
-        auth0Id: string;
-        email: string;
         id: string;
+        meta: {
+            createdAt: string;
+            updatedAt?: string;
+        };
+        auth0Id: null;
+        email: string;
         firstName: string;
         lastName: string;
         permissions: {
@@ -24,15 +25,49 @@ export declare class UsersApiClient {
         };
         phoneNumber: string;
         organizationId: string;
-        meta: {
-            createdAt: string;
-            updatedAt?: string;
-        };
+        hasPAT: boolean;
+    }> | import("./result").ResultErr<{
+        code: "NOT_AUTHENTICATED";
+    }> | import("./result").ResultErr<{
+        code: "UNKNOWN_ERROR";
+    }>>;
+    getSignUp({ token }: GetSignUpInput, opts?: ApiOptions): Promise<import("./result").ResultErr<{
+        code: "UNKNOWN_ERROR";
+    }> | import("./result").ResultOk<{
+        redirectUrl: string;
+        auth0Id?: string;
+        userId?: string;
+        organizationId?: string;
     }> | import("./result").ResultErr<{
+        code: "NOT_FOUND";
+    }>>;
+    createSignUpUser({ token, ...body }: CreateSignUpUserInput, opts?: ApiOptions): Promise<import("./result").ResultErr<{
         code: "NOT_AUTHENTICATED";
     }> | import("./result").ResultErr<{
         code: "UNKNOWN_ERROR";
+    }> | import("./result").ResultOk<{
+        redirectUrl: string;
+        auth0Id?: string;
+        userId?: string;
+        organizationId?: string;
+    }> | import("./result").ResultErr<{
+        code: "INVALID_STATE";
+    }>>;
+    getAuthToken({ code }: GetAuthTokenInput, opts?: ApiOptions): Promise<import("./result").ResultErr<{
+        code: "UNKNOWN_ERROR";
+    }> | import("./result").ResultOk<{
+        access_token: string;
+        id_token: string;
+        refresh_token: string;
+        expires_in: number;
+    }>>;
+    refreshToken({ refreshToken }: RefreshTokenInput, opts?: ApiOptions): Promise<import("./result").ResultErr<{
+        code: "UNKNOWN_ERROR";
+    }> | import("./result").ResultOk<{
+        access_token: string;
+        id_token: string;
+        refresh_token: string;
+        expires_in: number;
     }>>;
-    protected generateHeaders(opts?: ApiOptions): Headers;
-    protected mergeHeaders(overrides: Record<string, string>): Headers;
+    private getToken;
 }

package/dist/client.js

@@ -1,57 +1,107 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UsersApiClient = void 0;
-const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
-const result_1 = require("./result");
-class UsersApiClient {
-    client;
-    headers;
-    constructor(opts) {
-        this.client = (0, openapi_fetch_1.default)({ baseUrl: opts.apiUrl });
-        this.headers = new Headers();
-        if (opts.authToken) {
-            this.setAuthToken(opts.authToken);
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
         }
+    return t;
+};
+import { BaseClient } from "./base-client";
+import { Ok, Err } from "./result";
+export class UsersApiClient extends BaseClient {
+    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);
+            }
+            switch (response.status) {
+                case 401:
+                case 404:
+                    return Err("NOT_AUTHENTICATED");
+                default:
+                    return Err("UNKNOWN_ERROR");
+            }
+        });
     }
-    setAuthToken(authToken) {
-        this.headers.set("Authorization", `Bearer ${authToken}`);
+    getSignUp(_a, opts_1) {
+        return __awaiter(this, arguments, void 0, function* ({ token }, opts) {
+            const { data, response } = yield this.client.GET("/api/sign-ups/{token}", {
+                params: { path: { token } },
+                headers: this.generateHeaders(opts),
+            });
+            if (data) {
+                return Ok(data);
+            }
+            switch (response.status) {
+                case 404:
+                    return Err("NOT_FOUND");
+                default:
+                    return Err("UNKNOWN_ERROR");
+            }
+        });
     }
-    use(...middleware) {
-        this.client.use(...middleware);
+    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", {
+                headers: this.generateHeaders(opts),
+                params: { path: { token } },
+                body,
+            });
+            if (data) {
+                return Ok(data);
+            }
+            switch (response.status) {
+                case 401:
+                    return Err("NOT_AUTHENTICATED");
+                case 409:
+                    return Err("INVALID_STATE");
+                default:
+                    return Err("UNKNOWN_ERROR");
+            }
+        });
     }
-    async me(opts) {
-        const { data, response } = await this.client.GET("/api/users/me", {
-            headers: this.generateHeaders(opts),
+    getAuthToken(_a, opts_1) {
+        return __awaiter(this, arguments, void 0, function* ({ code }, opts) {
+            return this.getToken({ grant_type: "authorization_code", code }, 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");
-        }
     }
-    generateHeaders(opts) {
-        const headers = opts?.headers
-            ? this.mergeHeaders(opts.headers)
-            : new Headers(this.headers);
-        if (opts?.authToken) {
-            headers.set("Authorization", `Bearer ${opts.authToken}`);
-        }
-        return headers;
+    refreshToken(_a, opts_1) {
+        return __awaiter(this, arguments, void 0, function* ({ refreshToken }, opts) {
+            return this.getToken({
+                grant_type: "refresh_token",
+                refresh_token: refreshToken,
+            }, opts);
+        });
     }
-    mergeHeaders(overrides) {
-        const merged = new Headers(this.headers);
-        for (const key in overrides) {
-            merged.set(key, overrides[key]);
-        }
-        return merged;
+    getToken(input, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, response } = yield this.client.POST("/api/auth/token", {
+                headers: this.generateHeaders(opts),
+                body: input,
+            });
+            if (data) {
+                return Ok(data);
+            }
+            switch (response.status) {
+                default:
+                    return Err("UNKNOWN_ERROR");
+            }
+        });
     }
 }
-exports.UsersApiClient = UsersApiClient;

package/dist/main.js

@@ -1,17 +1 @@
-"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);
+export * from "./client";

package/dist/result.js

@@ -1,15 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Err = Err;
-exports.Ok = Ok;
-exports.assertOk = assertOk;
-function Err(code, extra) {
-    return { ok: false, error: { ...extra, code } };
+export function Err(code, extra) {
+    return { ok: false, error: Object.assign(Object.assign({}, extra), { code }) };
 }
-function Ok(data) {
+export function Ok(data) {
     return { ok: true, data };
 }
-function assertOk(result) {
+export function assertOk(result) {
     if (!result.ok) {
         throw new Error("Result was an error!");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palmetto/users-sdk",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "main": "./dist/main.js",
   "files": [
     "dist/**/*",