@voyantjs/auth-react 0.2.0

package/README.md

@@ -0,0 +1,23 @@
+# @voyantjs/auth-react
+
+React runtime package for Voyant authentication and workspace state.
+
+This package wraps the shared Voyant auth HTTP contract:
+
+- `/auth/me`
+- `/auth/status`
+- `/auth/workspace`
+- `/auth/workspace/active-organization`
+- `/auth/organization/list-members`
+- `/auth/organization/list-invitations`
+- `/auth/organization/invite-member`
+- `/auth/organization/update-member-role`
+- `/auth/organization/remove-member`
+- `/auth/organization/cancel-invitation`
+
+It provides reusable React surfaces for:
+
+- current user and workspace state
+- organization member listing
+- organization invitation listing
+- invite, cancel, remove, and role update mutations

package/dist/client.d.ts

@@ -0,0 +1,16 @@
+import type { z } from "zod";
+export type VoyantFetcher = (url: string, init?: RequestInit) => Promise<Response>;
+export declare const defaultFetcher: VoyantFetcher;
+export declare class VoyantApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export interface FetchWithValidationOptions {
+    baseUrl: string;
+    fetcher: VoyantFetcher;
+}
+export type QueryParamValue = string | number | boolean | null | undefined | Array<string | number | boolean>;
+export declare function fetchWithValidation<TOut>(path: string, schema: z.ZodType<TOut>, options: FetchWithValidationOptions, init?: RequestInit): Promise<TOut>;
+export declare function withQueryParams(path: string, query?: object): string;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAElF,eAAO,MAAM,cAAc,EAAE,aACoB,CAAA;AAEjD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAM3D;AAaD,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAA;AAEpC,wBAAsB,mBAAmB,CAAC,IAAI,EAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACvB,OAAO,EAAE,0BAA0B,EACnC,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,IAAI,CAAC,CA8Bf;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CA4BpE"}

package/dist/client.js

@@ -0,0 +1,81 @@
+export const defaultFetcher = (url, init) => fetch(url, { credentials: "include", ...init });
+export class VoyantApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "VoyantApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function extractErrorMessage(status, statusText, body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (typeof err === "string")
+            return err;
+        if (typeof err === "object" && err !== null && "message" in err) {
+            return String(err.message);
+        }
+    }
+    return `Voyant API error: ${status} ${statusText}`;
+}
+export async function fetchWithValidation(path, schema, options, init) {
+    const url = joinUrl(options.baseUrl, path);
+    const headers = new Headers(init?.headers);
+    if (init?.body !== undefined && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const response = await options.fetcher(url, { ...init, headers });
+    if (!response.ok) {
+        const body = await safeJson(response);
+        throw new VoyantApiError(extractErrorMessage(response.status, response.statusText, body), response.status, body);
+    }
+    if (response.status === 204)
+        return schema.parse(undefined);
+    const body = await safeJson(response);
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        throw new VoyantApiError(`Voyant API response failed validation: ${parsed.error.message}`, response.status, body);
+    }
+    return parsed.data;
+}
+export function withQueryParams(path, query) {
+    if (!query) {
+        return path;
+    }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                params.append(key, String(item));
+            }
+            continue;
+        }
+        params.set(key, String(value));
+    }
+    const serialized = params.toString();
+    if (!serialized) {
+        return path;
+    }
+    return `${path}?${serialized}`;
+}
+async function safeJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function joinUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const trimmedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,9 @@
+export { type UseAuthStatusOptions, useAuthStatus } from "./use-auth-status.js";
+export { type UseCurrentUserOptions, useCurrentUser } from "./use-current-user.js";
+export { type UseCurrentWorkspaceOptions, useCurrentWorkspace } from "./use-current-workspace.js";
+export { type CancelOrganizationInvitationInput, type InviteOrganizationMemberInput, useOrganizationInvitationMutation, } from "./use-organization-invitation-mutation.js";
+export { type UseOrganizationInvitationsOptions, useOrganizationInvitations, } from "./use-organization-invitations.js";
+export { type RemoveOrganizationMemberInput, type UpdateOrganizationMemberRoleInput, useOrganizationMemberMutation, } from "./use-organization-member-mutation.js";
+export { type UseOrganizationMembersOptions, useOrganizationMembers, } from "./use-organization-members.js";
+export { useWorkspaceMutation } from "./use-workspace-mutation.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAC/E,OAAO,EAAE,KAAK,qBAAqB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAClF,OAAO,EAAE,KAAK,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACjG,OAAO,EACL,KAAK,iCAAiC,EACtC,KAAK,6BAA6B,EAClC,iCAAiC,GAClC,MAAM,2CAA2C,CAAA;AAClD,OAAO,EACL,KAAK,iCAAiC,EACtC,0BAA0B,GAC3B,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,iCAAiC,EACtC,6BAA6B,GAC9B,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EACL,KAAK,6BAA6B,EAClC,sBAAsB,GACvB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,8 @@
+export { useAuthStatus } from "./use-auth-status.js";
+export { useCurrentUser } from "./use-current-user.js";
+export { useCurrentWorkspace } from "./use-current-workspace.js";
+export { useOrganizationInvitationMutation, } from "./use-organization-invitation-mutation.js";
+export { useOrganizationInvitations, } from "./use-organization-invitations.js";
+export { useOrganizationMemberMutation, } from "./use-organization-member-mutation.js";
+export { useOrganizationMembers, } from "./use-organization-members.js";
+export { useWorkspaceMutation } from "./use-workspace-mutation.js";

package/dist/hooks/use-auth-status.d.ts

@@ -0,0 +1,9 @@
+export interface UseAuthStatusOptions {
+    enabled?: boolean;
+}
+export declare function useAuthStatus(options?: UseAuthStatusOptions): import("@tanstack/react-query").UseQueryResult<{
+    userExists: boolean;
+    authenticated: boolean;
+    reason?: string | undefined;
+}, Error>;
+//# sourceMappingURL=use-auth-status.d.ts.map

package/dist/hooks/use-auth-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auth-status.d.ts","sourceRoot":"","sources":["../../src/hooks/use-auth-status.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB;;;;UAQ/D"}

package/dist/hooks/use-auth-status.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantAuthContext } from "../provider.js";
+import { getAuthStatusQueryOptions } from "../query-options.js";
+export function useAuthStatus(options = {}) {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getAuthStatusQueryOptions({ baseUrl, fetcher }),
+        enabled,
+    });
+}

package/dist/hooks/use-current-user.d.ts

@@ -0,0 +1,15 @@
+export interface UseCurrentUserOptions {
+    enabled?: boolean;
+}
+export declare function useCurrentUser(options?: UseCurrentUserOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    isSuperAdmin: boolean;
+    isSupportUser: boolean;
+    createdAt: string;
+    profilePictureUrl?: string | null | undefined;
+    activeOrganizationId?: string | null | undefined;
+}, Error>;
+//# sourceMappingURL=use-current-user.d.ts.map

package/dist/hooks/use-current-user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-current-user.d.ts","sourceRoot":"","sources":["../../src/hooks/use-current-user.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;UAQjE"}

package/dist/hooks/use-current-user.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantAuthContext } from "../provider.js";
+import { getCurrentUserQueryOptions } from "../query-options.js";
+export function useCurrentUser(options = {}) {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getCurrentUserQueryOptions({ baseUrl, fetcher }),
+        enabled,
+    });
+}

package/dist/hooks/use-current-workspace.d.ts

@@ -0,0 +1,18 @@
+export interface UseCurrentWorkspaceOptions {
+    enabled?: boolean;
+}
+export declare function useCurrentWorkspace(options?: UseCurrentWorkspaceOptions): import("@tanstack/react-query").UseQueryResult<{
+    organizations: {
+        id: string;
+        name: string;
+        slug: string;
+        logo?: string | null | undefined;
+    }[];
+    activeOrganization: {
+        id: string;
+        name: string;
+        slug: string;
+        logo?: string | null | undefined;
+    } | null;
+}, Error>;
+//# sourceMappingURL=use-current-workspace.d.ts.map

package/dist/hooks/use-current-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-current-workspace.d.ts","sourceRoot":"","sources":["../../src/hooks/use-current-workspace.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;;;;;;;;;UAQ3E"}

package/dist/hooks/use-current-workspace.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantAuthContext } from "../provider.js";
+import { getCurrentWorkspaceQueryOptions } from "../query-options.js";
+export function useCurrentWorkspace(options = {}) {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const { enabled = true } = options;
+    return useQuery({
+        ...getCurrentWorkspaceQueryOptions({ baseUrl, fetcher }),
+        enabled,
+    });
+}

package/dist/hooks/use-organization-invitation-mutation.d.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod";
+import { type organizationRoleSchema } from "../schemas.js";
+export interface InviteOrganizationMemberInput {
+    email: string;
+    role: z.input<typeof organizationRoleSchema>;
+    organizationId?: string | undefined;
+    resend?: boolean | undefined;
+}
+export interface CancelOrganizationInvitationInput {
+    invitationId: string;
+}
+export declare function useOrganizationInvitationMutation(): {
+    invite: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        organizationId: string;
+        email: string;
+        role: string | string[];
+        status: "pending" | "accepted" | "rejected" | "canceled";
+        inviterId: string;
+        expiresAt: string;
+        createdAt: string;
+        teamId?: string | undefined;
+    }, Error, InviteOrganizationMemberInput, unknown>;
+    cancel: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        organizationId: string;
+        email: string;
+        role: string | string[];
+        status: "pending" | "accepted" | "rejected" | "canceled";
+        inviterId: string;
+        expiresAt: string;
+        createdAt: string;
+        teamId?: string | undefined;
+    } | null, Error, CancelOrganizationInvitationInput, unknown>;
+};
+//# sourceMappingURL=use-organization-invitation-mutation.d.ts.map

package/dist/hooks/use-organization-invitation-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-organization-invitation-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-organization-invitation-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAK5B,OAAO,EAAgC,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAEzF,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;IAC5C,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC7B;AAED,MAAM,WAAW,iCAAiC;IAChD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;EA+BhD"}

package/dist/hooks/use-organization-invitation-mutation.js

@@ -0,0 +1,23 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAuthContext } from "../provider.js";
+import { authQueryKeys } from "../query-keys.js";
+import { organizationInvitationSchema } from "../schemas.js";
+export function useOrganizationInvitationMutation() {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const queryClient = useQueryClient();
+    const invite = useMutation({
+        mutationFn: async (input) => fetchWithValidation("/auth/organization/invite-member", organizationInvitationSchema, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) }),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: authQueryKeys.organizationInvitations() });
+        },
+    });
+    const cancel = useMutation({
+        mutationFn: async (input) => fetchWithValidation("/auth/organization/cancel-invitation", organizationInvitationSchema.nullable(), { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) }),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: authQueryKeys.organizationInvitations() });
+        },
+    });
+    return { invite, cancel };
+}

package/dist/hooks/use-organization-invitations.d.ts

@@ -0,0 +1,17 @@
+import type { OrganizationInvitationsListFilters } from "../query-keys.js";
+export interface UseOrganizationInvitationsOptions {
+    filters?: OrganizationInvitationsListFilters;
+    enabled?: boolean;
+}
+export declare function useOrganizationInvitations(options?: UseOrganizationInvitationsOptions): import("@tanstack/react-query").UseQueryResult<{
+    id: string;
+    organizationId: string;
+    email: string;
+    role: string | string[];
+    status: "pending" | "accepted" | "rejected" | "canceled";
+    inviterId: string;
+    expiresAt: string;
+    createdAt: string;
+    teamId?: string | undefined;
+}[], Error>;
+//# sourceMappingURL=use-organization-invitations.d.ts.map

package/dist/hooks/use-organization-invitations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-organization-invitations.d.ts","sourceRoot":"","sources":["../../src/hooks/use-organization-invitations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,kBAAkB,CAAA;AAG1E,MAAM,WAAW,iCAAiC;IAChD,OAAO,CAAC,EAAE,kCAAkC,CAAA;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iCAAsC;;;;;;;;;;YAQzF"}

package/dist/hooks/use-organization-invitations.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantAuthContext } from "../provider.js";
+import { getOrganizationInvitationsQueryOptions } from "../query-options.js";
+export function useOrganizationInvitations(options = {}) {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const { filters = {}, enabled = true } = options;
+    return useQuery({
+        ...getOrganizationInvitationsQueryOptions(filters, { baseUrl, fetcher }),
+        enabled,
+    });
+}

package/dist/hooks/use-organization-member-mutation.d.ts

@@ -0,0 +1,44 @@
+import type { z } from "zod";
+import { type organizationRoleSchema } from "../schemas.js";
+export interface UpdateOrganizationMemberRoleInput {
+    memberId: string;
+    role: z.input<typeof organizationRoleSchema>;
+    organizationId?: string | undefined;
+}
+export interface RemoveOrganizationMemberInput {
+    memberIdOrEmail: string;
+    organizationId?: string | undefined;
+}
+export declare function useOrganizationMemberMutation(): {
+    updateRole: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: string | string[];
+        createdAt: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | null | undefined;
+        };
+        teamId?: string | undefined;
+    }, Error, UpdateOrganizationMemberRoleInput, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        member: {
+            id: string;
+            organizationId: string;
+            userId: string;
+            role: string | string[];
+            createdAt: string;
+            user: {
+                id: string;
+                email: string;
+                name: string;
+                image?: string | null | undefined;
+            };
+            teamId?: string | undefined;
+        };
+    }, Error, RemoveOrganizationMemberInput, unknown>;
+};
+//# sourceMappingURL=use-organization-member-mutation.d.ts.map

package/dist/hooks/use-organization-member-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-organization-member-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-organization-member-mutation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAK5B,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAA;AAEtB,MAAM,WAAW,iCAAiC;IAChD,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;IAC5C,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;AAED,MAAM,WAAW,6BAA6B;IAC5C,eAAe,EAAE,MAAM,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;AAED,wBAAgB,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC5C"}

package/dist/hooks/use-organization-member-mutation.js

@@ -0,0 +1,25 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAuthContext } from "../provider.js";
+import { authQueryKeys } from "../query-keys.js";
+import { organizationMemberSchema, organizationRemoveMemberSchema, } from "../schemas.js";
+export function useOrganizationMemberMutation() {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const queryClient = useQueryClient();
+    const updateRole = useMutation({
+        mutationFn: async (input) => fetchWithValidation("/auth/organization/update-member-role", organizationMemberSchema, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) }),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: authQueryKeys.organizationMembers() });
+        },
+    });
+    const remove = useMutation({
+        mutationFn: async (input) => fetchWithValidation("/auth/organization/remove-member", organizationRemoveMemberSchema, { baseUrl, fetcher }, { method: "POST", body: JSON.stringify(input) }),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: authQueryKeys.organizationMembers() });
+            void queryClient.invalidateQueries({ queryKey: authQueryKeys.currentWorkspace() });
+            void queryClient.invalidateQueries({ queryKey: authQueryKeys.currentUser() });
+        },
+    });
+    return { updateRole, remove };
+}

package/dist/hooks/use-organization-members.d.ts

@@ -0,0 +1,23 @@
+import type { OrganizationMembersListFilters } from "../query-keys.js";
+export interface UseOrganizationMembersOptions {
+    filters?: OrganizationMembersListFilters;
+    enabled?: boolean;
+}
+export declare function useOrganizationMembers(options?: UseOrganizationMembersOptions): import("@tanstack/react-query").UseQueryResult<{
+    members: {
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: string | string[];
+        createdAt: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | null | undefined;
+        };
+        teamId?: string | undefined;
+    }[];
+    total: number;
+}, Error>;
+//# sourceMappingURL=use-organization-members.d.ts.map

package/dist/hooks/use-organization-members.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-organization-members.d.ts","sourceRoot":"","sources":["../../src/hooks/use-organization-members.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,kBAAkB,CAAA;AAGtE,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,EAAE,8BAA8B,CAAA;IACxC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,6BAAkC;;;;;;;;;;;;;;;;UAQjF"}

package/dist/hooks/use-organization-members.js

@@ -0,0 +1,12 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { useVoyantAuthContext } from "../provider.js";
+import { getOrganizationMembersQueryOptions } from "../query-options.js";
+export function useOrganizationMembers(options = {}) {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const { filters = {}, enabled = true } = options;
+    return useQuery({
+        ...getOrganizationMembersQueryOptions(filters, { baseUrl, fetcher }),
+        enabled,
+    });
+}

package/dist/hooks/use-workspace-mutation.d.ts

@@ -0,0 +1,28 @@
+export declare function useWorkspaceMutation(): {
+    setActiveOrganization: import("@tanstack/react-query").UseMutationResult<{
+        organizations: {
+            id: string;
+            name: string;
+            slug: string;
+            logo?: string | null | undefined;
+        }[];
+        activeOrganization: {
+            id: string;
+            name: string;
+            slug: string;
+            logo?: string | null | undefined;
+        } | null;
+    }, Error, string, unknown>;
+    refreshCurrentUser: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        email: string;
+        firstName: string | null;
+        lastName: string | null;
+        isSuperAdmin: boolean;
+        isSupportUser: boolean;
+        createdAt: string;
+        profilePictureUrl?: string | null | undefined;
+        activeOrganizationId?: string | null | undefined;
+    }, Error, void, unknown>;
+};
+//# sourceMappingURL=use-workspace-mutation.d.ts.map

package/dist/hooks/use-workspace-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-workspace-mutation.d.ts","sourceRoot":"","sources":["../../src/hooks/use-workspace-mutation.ts"],"names":[],"mappings":"AASA,wBAAgB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BnC"}

package/dist/hooks/use-workspace-mutation.js

@@ -0,0 +1,27 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetchWithValidation } from "../client.js";
+import { useVoyantAuthContext } from "../provider.js";
+import { authQueryKeys } from "../query-keys.js";
+import { currentUserSchema, currentWorkspaceSchema } from "../schemas.js";
+export function useWorkspaceMutation() {
+    const { baseUrl, fetcher } = useVoyantAuthContext();
+    const queryClient = useQueryClient();
+    const setActiveOrganization = useMutation({
+        mutationFn: async (organizationId) => fetchWithValidation("/auth/workspace/active-organization", currentWorkspaceSchema, { baseUrl, fetcher }, {
+            method: "POST",
+            body: JSON.stringify({ organizationId }),
+        }),
+        onSuccess: (workspace) => {
+            queryClient.setQueryData(authQueryKeys.currentWorkspace(), workspace);
+            void queryClient.invalidateQueries({ queryKey: authQueryKeys.currentUser() });
+        },
+    });
+    const refreshCurrentUser = useMutation({
+        mutationFn: async () => fetchWithValidation("/auth/me", currentUserSchema, { baseUrl, fetcher }),
+        onSuccess: (user) => {
+            queryClient.setQueryData(authQueryKeys.currentUser(), user);
+        },
+    });
+    return { setActiveOrganization, refreshCurrentUser };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { AuthStatus, CurrentUser, CurrentWorkspace, WorkspaceOrganization, } from "@voyantjs/auth/workspace";
+export { defaultFetcher, fetchWithValidation, VoyantApiError, type VoyantFetcher, withQueryParams, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantAuthContext, type VoyantAuthContextValue, VoyantAuthProvider, type VoyantAuthProviderProps, } from "./provider.js";
+export type { OrganizationInvitationsListFilters, OrganizationMembersListFilters, } from "./query-keys.js";
+export { authQueryKeys } from "./query-keys.js";
+export { getAuthStatusQueryOptions, getCurrentUserQueryOptions, getCurrentWorkspaceQueryOptions, getOrganizationInvitationsQueryOptions, getOrganizationMembersQueryOptions, } from "./query-options.js";
+export * from "./schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,KAAK,aAAa,EAClB,eAAe,GAChB,MAAM,aAAa,CAAA;AACpB,cAAc,kBAAkB,CAAA;AAChC,OAAO,EACL,oBAAoB,EACpB,KAAK,sBAAsB,EAC3B,kBAAkB,EAClB,KAAK,uBAAuB,GAC7B,MAAM,eAAe,CAAA;AACtB,YAAY,EACV,kCAAkC,EAClC,8BAA8B,GAC/B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,+BAA+B,EAC/B,sCAAsC,EACtC,kCAAkC,GACnC,MAAM,oBAAoB,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { defaultFetcher, fetchWithValidation, VoyantApiError, withQueryParams, } from "./client.js";
+export * from "./hooks/index.js";
+export { useVoyantAuthContext, VoyantAuthProvider, } from "./provider.js";
+export { authQueryKeys } from "./query-keys.js";
+export { getAuthStatusQueryOptions, getCurrentUserQueryOptions, getCurrentWorkspaceQueryOptions, getOrganizationInvitationsQueryOptions, getOrganizationMembersQueryOptions, } from "./query-options.js";
+export * from "./schemas.js";

package/dist/provider.d.ts

@@ -0,0 +1,2 @@
+export { useVoyantReactContext as useVoyantAuthContext, type VoyantReactContextValue as VoyantAuthContextValue, VoyantReactProvider as VoyantAuthProvider, type VoyantReactProviderProps as VoyantAuthProviderProps, } from "@voyantjs/react";
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,IAAI,oBAAoB,EAC7C,KAAK,uBAAuB,IAAI,sBAAsB,EACtD,mBAAmB,IAAI,kBAAkB,EACzC,KAAK,wBAAwB,IAAI,uBAAuB,GACzD,MAAM,iBAAiB,CAAA"}

package/dist/provider.js

@@ -0,0 +1 @@
+export { useVoyantReactContext as useVoyantAuthContext, VoyantReactProvider as VoyantAuthProvider, } from "@voyantjs/react";

package/dist/query-keys.d.ts

@@ -0,0 +1,25 @@
+export interface OrganizationMembersListFilters {
+    limit?: number | string | undefined;
+    offset?: number | string | undefined;
+    sortBy?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+    filterField?: string | undefined;
+    filterValue?: string | number | boolean | Array<string | number> | undefined;
+    filterOperator?: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+}
+export interface OrganizationInvitationsListFilters {
+    organizationId?: string | undefined;
+}
+export declare const authQueryKeys: {
+    all: readonly ["auth"];
+    currentUser: () => readonly ["auth", "current-user"];
+    currentWorkspace: () => readonly ["auth", "current-workspace"];
+    authStatus: () => readonly ["auth", "status"];
+    organizationMembers: () => readonly ["auth", "organization-members"];
+    organizationMembersList: (filters?: OrganizationMembersListFilters) => readonly ["auth", "organization-members", "list", OrganizationMembersListFilters];
+    organizationInvitations: () => readonly ["auth", "organization-invitations"];
+    organizationInvitationsList: (filters?: OrganizationInvitationsListFilters) => readonly ["auth", "organization-invitations", "list", OrganizationInvitationsListFilters];
+};
+//# sourceMappingURL=query-keys.d.ts.map

package/dist/query-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-keys.d.ts","sourceRoot":"","sources":["../src/query-keys.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,8BAA8B;IAC7C,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;IACnC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;IACpC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,aAAa,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAAA;IAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5E,cAAc,CAAC,EACX,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,QAAQ,GACR,UAAU,GACV,aAAa,GACb,WAAW,GACX,SAAS,CAAA;IACb,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACtC;AAED,MAAM,WAAW,kCAAkC;IACjD,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;AAED,eAAO,MAAM,aAAa;;;;;;wCAMW,8BAA8B;;4CAG1B,kCAAkC;CAE1E,CAAA"}

package/dist/query-keys.js

@@ -0,0 +1,10 @@
+export const authQueryKeys = {
+    all: ["auth"],
+    currentUser: () => [...authQueryKeys.all, "current-user"],
+    currentWorkspace: () => [...authQueryKeys.all, "current-workspace"],
+    authStatus: () => [...authQueryKeys.all, "status"],
+    organizationMembers: () => [...authQueryKeys.all, "organization-members"],
+    organizationMembersList: (filters = {}) => [...authQueryKeys.organizationMembers(), "list", filters],
+    organizationInvitations: () => [...authQueryKeys.all, "organization-invitations"],
+    organizationInvitationsList: (filters = {}) => [...authQueryKeys.organizationInvitations(), "list", filters],
+};

package/dist/query-options.d.ts

@@ -0,0 +1,256 @@
+import { type FetchWithValidationOptions } from "./client.js";
+import { type OrganizationInvitationsListFilters, type OrganizationMembersListFilters } from "./query-keys.js";
+export declare function getCurrentUserQueryOptions(client: FetchWithValidationOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    isSuperAdmin: boolean;
+    isSupportUser: boolean;
+    createdAt: string;
+    profilePictureUrl?: string | null | undefined;
+    activeOrganizationId?: string | null | undefined;
+}, Error, {
+    id: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    isSuperAdmin: boolean;
+    isSupportUser: boolean;
+    createdAt: string;
+    profilePictureUrl?: string | null | undefined;
+    activeOrganizationId?: string | null | undefined;
+}, readonly ["auth", "current-user"]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        id: string;
+        email: string;
+        firstName: string | null;
+        lastName: string | null;
+        isSuperAdmin: boolean;
+        isSupportUser: boolean;
+        createdAt: string;
+        profilePictureUrl?: string | null | undefined;
+        activeOrganizationId?: string | null | undefined;
+    }, readonly ["auth", "current-user"], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "current-user"] & {
+        [dataTagSymbol]: {
+            id: string;
+            email: string;
+            firstName: string | null;
+            lastName: string | null;
+            isSuperAdmin: boolean;
+            isSupportUser: boolean;
+            createdAt: string;
+            profilePictureUrl?: string | null | undefined;
+            activeOrganizationId?: string | null | undefined;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getCurrentWorkspaceQueryOptions(client: FetchWithValidationOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    organizations: {
+        id: string;
+        name: string;
+        slug: string;
+        logo?: string | null | undefined;
+    }[];
+    activeOrganization: {
+        id: string;
+        name: string;
+        slug: string;
+        logo?: string | null | undefined;
+    } | null;
+}, Error, {
+    organizations: {
+        id: string;
+        name: string;
+        slug: string;
+        logo?: string | null | undefined;
+    }[];
+    activeOrganization: {
+        id: string;
+        name: string;
+        slug: string;
+        logo?: string | null | undefined;
+    } | null;
+}, readonly ["auth", "current-workspace"]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        organizations: {
+            id: string;
+            name: string;
+            slug: string;
+            logo?: string | null | undefined;
+        }[];
+        activeOrganization: {
+            id: string;
+            name: string;
+            slug: string;
+            logo?: string | null | undefined;
+        } | null;
+    }, readonly ["auth", "current-workspace"], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "current-workspace"] & {
+        [dataTagSymbol]: {
+            organizations: {
+                id: string;
+                name: string;
+                slug: string;
+                logo?: string | null | undefined;
+            }[];
+            activeOrganization: {
+                id: string;
+                name: string;
+                slug: string;
+                logo?: string | null | undefined;
+            } | null;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getAuthStatusQueryOptions(client: FetchWithValidationOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    userExists: boolean;
+    authenticated: boolean;
+    reason?: string | undefined;
+}, Error, {
+    userExists: boolean;
+    authenticated: boolean;
+    reason?: string | undefined;
+}, readonly ["auth", "status"]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        userExists: boolean;
+        authenticated: boolean;
+        reason?: string | undefined;
+    }, readonly ["auth", "status"], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "status"] & {
+        [dataTagSymbol]: {
+            userExists: boolean;
+            authenticated: boolean;
+            reason?: string | undefined;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getOrganizationMembersQueryOptions(filters: OrganizationMembersListFilters, client: FetchWithValidationOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    members: {
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: string | string[];
+        createdAt: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | null | undefined;
+        };
+        teamId?: string | undefined;
+    }[];
+    total: number;
+}, Error, {
+    members: {
+        id: string;
+        organizationId: string;
+        userId: string;
+        role: string | string[];
+        createdAt: string;
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string | null | undefined;
+        };
+        teamId?: string | undefined;
+    }[];
+    total: number;
+}, readonly ["auth", "organization-members", "list", OrganizationMembersListFilters]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        members: {
+            id: string;
+            organizationId: string;
+            userId: string;
+            role: string | string[];
+            createdAt: string;
+            user: {
+                id: string;
+                email: string;
+                name: string;
+                image?: string | null | undefined;
+            };
+            teamId?: string | undefined;
+        }[];
+        total: number;
+    }, readonly ["auth", "organization-members", "list", OrganizationMembersListFilters], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "organization-members", "list", OrganizationMembersListFilters] & {
+        [dataTagSymbol]: {
+            members: {
+                id: string;
+                organizationId: string;
+                userId: string;
+                role: string | string[];
+                createdAt: string;
+                user: {
+                    id: string;
+                    email: string;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+                teamId?: string | undefined;
+            }[];
+            total: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function getOrganizationInvitationsQueryOptions(filters: OrganizationInvitationsListFilters, client: FetchWithValidationOptions): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+    id: string;
+    organizationId: string;
+    email: string;
+    role: string | string[];
+    status: "pending" | "accepted" | "rejected" | "canceled";
+    inviterId: string;
+    expiresAt: string;
+    createdAt: string;
+    teamId?: string | undefined;
+}[], Error, {
+    id: string;
+    organizationId: string;
+    email: string;
+    role: string | string[];
+    status: "pending" | "accepted" | "rejected" | "canceled";
+    inviterId: string;
+    expiresAt: string;
+    createdAt: string;
+    teamId?: string | undefined;
+}[], readonly ["auth", "organization-invitations", "list", OrganizationInvitationsListFilters]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<{
+        id: string;
+        organizationId: string;
+        email: string;
+        role: string | string[];
+        status: "pending" | "accepted" | "rejected" | "canceled";
+        inviterId: string;
+        expiresAt: string;
+        createdAt: string;
+        teamId?: string | undefined;
+    }[], readonly ["auth", "organization-invitations", "list", OrganizationInvitationsListFilters], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "organization-invitations", "list", OrganizationInvitationsListFilters] & {
+        [dataTagSymbol]: {
+            id: string;
+            organizationId: string;
+            email: string;
+            role: string | string[];
+            status: "pending" | "accepted" | "rejected" | "canceled";
+            inviterId: string;
+            expiresAt: string;
+            createdAt: string;
+            teamId?: string | undefined;
+        }[];
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export type { OrganizationInvitationsListFilters, OrganizationMembersListFilters, } from "./query-keys.js";
+//# sourceMappingURL=query-options.d.ts.map

package/dist/query-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-options.d.ts","sourceRoot":"","sources":["../src/query-options.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,0BAA0B,EAAwC,MAAM,aAAa,CAAA;AACnG,OAAO,EAEL,KAAK,kCAAkC,EACvC,KAAK,8BAA8B,EACpC,MAAM,iBAAiB,CAAA;AASxB,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5E;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjF;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;EAK3E;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,8BAA8B,EACvC,MAAM,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWnC;AAED,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,kCAAkC,EAC3C,MAAM,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWnC;AAED,YAAY,EACV,kCAAkC,EAClC,8BAA8B,GAC/B,MAAM,iBAAiB,CAAA"}

package/dist/query-options.js

@@ -0,0 +1,35 @@
+"use client";
+import { queryOptions } from "@tanstack/react-query";
+import { fetchWithValidation, withQueryParams } from "./client.js";
+import { authQueryKeys, } from "./query-keys.js";
+import { authStatusSchema, currentUserSchema, currentWorkspaceSchema, organizationInvitationsListSchema, organizationMembersListSchema, } from "./schemas.js";
+export function getCurrentUserQueryOptions(client) {
+    return queryOptions({
+        queryKey: authQueryKeys.currentUser(),
+        queryFn: () => fetchWithValidation("/auth/me", currentUserSchema, client),
+    });
+}
+export function getCurrentWorkspaceQueryOptions(client) {
+    return queryOptions({
+        queryKey: authQueryKeys.currentWorkspace(),
+        queryFn: () => fetchWithValidation("/auth/workspace", currentWorkspaceSchema, client),
+    });
+}
+export function getAuthStatusQueryOptions(client) {
+    return queryOptions({
+        queryKey: authQueryKeys.authStatus(),
+        queryFn: () => fetchWithValidation("/auth/status", authStatusSchema, client),
+    });
+}
+export function getOrganizationMembersQueryOptions(filters, client) {
+    return queryOptions({
+        queryKey: authQueryKeys.organizationMembersList(filters),
+        queryFn: () => fetchWithValidation(withQueryParams("/auth/organization/list-members", filters), organizationMembersListSchema, client),
+    });
+}
+export function getOrganizationInvitationsQueryOptions(filters, client) {
+    return queryOptions({
+        queryKey: authQueryKeys.organizationInvitationsList(filters),
+        queryFn: () => fetchWithValidation(withQueryParams("/auth/organization/list-invitations", filters), organizationInvitationsListSchema, client),
+    });
+}

package/dist/schemas.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export declare const organizationRoleSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+export declare const organizationInvitationStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    accepted: "accepted";
+    rejected: "rejected";
+    canceled: "canceled";
+}>;
+export declare const workspaceOrganizationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    logo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const currentWorkspaceSchema: z.ZodObject<{
+    organizations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        logo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    activeOrganization: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        logo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const currentUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    firstName: z.ZodNullable<z.ZodString>;
+    lastName: z.ZodNullable<z.ZodString>;
+    isSuperAdmin: z.ZodBoolean;
+    isSupportUser: z.ZodBoolean;
+    createdAt: z.ZodString;
+    profilePictureUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    activeOrganizationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const authStatusSchema: z.ZodObject<{
+    userExists: z.ZodBoolean;
+    authenticated: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const organizationMemberUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodString;
+    image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const organizationMemberSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    userId: z.ZodString;
+    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    createdAt: z.ZodString;
+    teamId: z.ZodOptional<z.ZodString>;
+    user: z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        name: z.ZodString;
+        image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const organizationMembersListSchema: z.ZodObject<{
+    members: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        organizationId: z.ZodString;
+        userId: z.ZodString;
+        role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        createdAt: z.ZodString;
+        teamId: z.ZodOptional<z.ZodString>;
+        user: z.ZodObject<{
+            id: z.ZodString;
+            email: z.ZodString;
+            name: z.ZodString;
+            image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export declare const organizationRemoveMemberSchema: z.ZodObject<{
+    member: z.ZodObject<{
+        id: z.ZodString;
+        organizationId: z.ZodString;
+        userId: z.ZodString;
+        role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        createdAt: z.ZodString;
+        teamId: z.ZodOptional<z.ZodString>;
+        user: z.ZodObject<{
+            id: z.ZodString;
+            email: z.ZodString;
+            name: z.ZodString;
+            image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const organizationInvitationSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    email: z.ZodString;
+    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        accepted: "accepted";
+        rejected: "rejected";
+        canceled: "canceled";
+    }>;
+    inviterId: z.ZodString;
+    expiresAt: z.ZodString;
+    createdAt: z.ZodString;
+    teamId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const organizationInvitationsListSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    email: z.ZodString;
+    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        accepted: "accepted";
+        rejected: "rejected";
+        canceled: "canceled";
+    }>;
+    inviterId: z.ZodString;
+    expiresAt: z.ZodString;
+    createdAt: z.ZodString;
+    teamId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,sBAAsB,6DAA6C,CAAA;AAEhF,eAAO,MAAM,kCAAkC;;;;;EAK7C,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;iBAKtC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;iBAGjC,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;iBAU5B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;iBAI3B,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;iBAKvC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;iBAQnC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;iBAGxC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;iBAEzC,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;iBAUvC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;kBAAwC,CAAA"}

package/dist/schemas.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export const organizationRoleSchema = z.union([z.string(), z.array(z.string())]);
+export const organizationInvitationStatusSchema = z.enum([
+    "pending",
+    "accepted",
+    "rejected",
+    "canceled",
+]);
+export const workspaceOrganizationSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    slug: z.string(),
+    logo: z.string().nullable().optional(),
+});
+export const currentWorkspaceSchema = z.object({
+    organizations: z.array(workspaceOrganizationSchema),
+    activeOrganization: workspaceOrganizationSchema.nullable(),
+});
+export const currentUserSchema = z.object({
+    id: z.string(),
+    email: z.string(),
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+    isSuperAdmin: z.boolean(),
+    isSupportUser: z.boolean(),
+    createdAt: z.string(),
+    profilePictureUrl: z.string().nullable().optional(),
+    activeOrganizationId: z.string().nullable().optional(),
+});
+export const authStatusSchema = z.object({
+    userExists: z.boolean(),
+    authenticated: z.boolean(),
+    reason: z.string().optional(),
+});
+export const organizationMemberUserSchema = z.object({
+    id: z.string(),
+    email: z.string(),
+    name: z.string(),
+    image: z.string().nullable().optional(),
+});
+export const organizationMemberSchema = z.object({
+    id: z.string(),
+    organizationId: z.string(),
+    userId: z.string(),
+    role: organizationRoleSchema,
+    createdAt: z.string(),
+    teamId: z.string().optional(),
+    user: organizationMemberUserSchema,
+});
+export const organizationMembersListSchema = z.object({
+    members: z.array(organizationMemberSchema),
+    total: z.number(),
+});
+export const organizationRemoveMemberSchema = z.object({
+    member: organizationMemberSchema,
+});
+export const organizationInvitationSchema = z.object({
+    id: z.string(),
+    organizationId: z.string(),
+    email: z.string(),
+    role: organizationRoleSchema,
+    status: organizationInvitationStatusSchema,
+    inviterId: z.string(),
+    expiresAt: z.string(),
+    createdAt: z.string(),
+    teamId: z.string().optional(),
+});
+export const organizationInvitationsListSchema = z.array(organizationInvitationSchema);

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@voyantjs/auth-react",
+  "version": "0.2.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/auth-react"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./provider": "./src/provider.tsx",
+    "./hooks": "./src/hooks/index.ts",
+    "./client": "./src/client.ts",
+    "./query-keys": "./src/query-keys.ts"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run --passWithNoTests"
+  },
+  "peerDependencies": {
+    "@voyantjs/auth": "workspace:*",
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.96.2",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@voyantjs/auth": "workspace:*",
+    "@voyantjs/react": "workspace:*",
+    "@voyantjs/voyant-typescript-config": "workspace:*",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2",
+    "zod": "^4.3.6"
+  },
+  "dependencies": {
+    "@voyantjs/react": "workspace:*"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./provider": {
+        "types": "./dist/provider.d.ts",
+        "import": "./dist/provider.js"
+      },
+      "./hooks": {
+        "types": "./dist/hooks/index.d.ts",
+        "import": "./dist/hooks/index.js"
+      },
+      "./client": {
+        "types": "./dist/client.d.ts",
+        "import": "./dist/client.js"
+      },
+      "./query-keys": {
+        "types": "./dist/query-keys.d.ts",
+        "import": "./dist/query-keys.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  }
+}