@gatwech/auth 1.0.0-beta.18

package/dist/src/api/to-auth-endpoints.d.ts

@@ -0,0 +1,3 @@
+import type { AuthContext } from "@gatwech/core";
+import type { AuthEndpoint } from "@gatwech/core/api";
+export declare function toAuthEndpoints<const E extends Record<string, Omit<AuthEndpoint, "wrap">>>(endpoints: E, ctx: AuthContext | Promise<AuthContext>): E;

package/dist/src/auth.d.ts

@@ -0,0 +1,25 @@
+import type { AuthContext, PayvoAuthOptions } from "@gatwech/core";
+import { BASE_ERROR_CODES } from "@gatwech/core/error";
+import { router } from "./api";
+import type { InferAPI, InferPluginErrorCodes, InferPluginTypes, InferSession, InferUser } from "./types";
+import type { Expand, PrettifyDeep } from "./types/helper";
+export type WithJsDoc<T, D> = Expand<T & D>;
+export declare const payvoAuth: <Options extends PayvoAuthOptions>(options: Options & Record<never, never>) => Auth<Options>;
+export type Auth<Options extends PayvoAuthOptions = PayvoAuthOptions> = {
+    handler: (request: Request) => Promise<Response>;
+    api: InferAPI<ReturnType<typeof router<Options>>["endpoints"]>;
+    options: Options;
+    $ERROR_CODES: InferPluginErrorCodes<Options> & typeof BASE_ERROR_CODES;
+    $context: Promise<AuthContext>;
+    /**
+     * Share types
+     */
+    $Infer: InferPluginTypes<Options> extends {
+        Session: any;
+    } ? InferPluginTypes<Options> : {
+        Session: {
+            session: PrettifyDeep<InferSession<Options>>;
+            user: PrettifyDeep<InferUser<Options>>;
+        };
+    } & InferPluginTypes<Options>;
+};

package/dist/src/client/broadcast-channel.d.ts

@@ -0,0 +1,12 @@
+export interface BroadcastMessage {
+    event?: "session" | undefined;
+    data?: {
+        trigger?: "signout" | "getSession" | "updateUser";
+    } | undefined;
+    clientId: string;
+    timestamp: number;
+}
+export declare function createBroadcastChannel(name?: string): {
+    receive(onReceive: (message: BroadcastMessage) => void): () => void;
+    post(message: Record<string, unknown>): void;
+};

package/dist/src/client/config.d.ts

@@ -0,0 +1,85 @@
+import type { PayvoAuthClientOptions, ClientAtomListener } from "@gatwech/core";
+import { type WritableAtom } from "nanostores";
+export declare const getClientConfig: (options?: PayvoAuthClientOptions | undefined, loadEnv?: boolean | undefined) => {
+    readonly baseURL: string;
+    pluginsActions: Record<string, any>;
+    pluginsAtoms: Record<string, WritableAtom<any>>;
+    pluginPathMethods: Record<string, "GET" | "POST">;
+    atomListeners: ClientAtomListener[];
+    $fetch: import("@better-fetch/fetch").BetterFetch<{
+        plugins: (import("@better-fetch/fetch").BetterFetchPlugin | {
+            id: string;
+            name: string;
+            hooks: {
+                onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): void;
+            };
+        } | {
+            id: string;
+            name: string;
+            hooks: {
+                onRequest<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>): void;
+            };
+        } | {
+            id: string;
+            name: string;
+            hooks: {
+                onSuccess: ((context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void> | void) | undefined;
+                onError: ((context: import("@better-fetch/fetch").ErrorContext) => Promise<void> | void) | undefined;
+                onRequest: (<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>) => Promise<import("@better-fetch/fetch").RequestContext | void> | import("@better-fetch/fetch").RequestContext | void) | undefined;
+                onResponse: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
+            };
+        })[];
+        method: string;
+        headers?: (HeadersInit & (HeadersInit | {
+            accept: "application/json" | "text/plain" | "application/octet-stream";
+            "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+            authorization: "Bearer" | "Basic";
+        })) | undefined;
+        redirect?: RequestRedirect | undefined;
+        cache?: RequestCache | undefined;
+        credentials?: RequestCredentials;
+        integrity?: string | undefined;
+        keepalive?: boolean | undefined;
+        mode?: RequestMode | undefined;
+        priority?: RequestPriority | undefined;
+        referrer?: string | undefined;
+        referrerPolicy?: ReferrerPolicy | undefined;
+        signal?: (AbortSignal | null) | undefined;
+        window?: null | undefined;
+        onRetry?: ((response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void) | undefined;
+        hookOptions?: {
+            cloneResponse?: boolean;
+        } | undefined;
+        timeout?: number | undefined;
+        customFetchImpl: import("@better-fetch/fetch").FetchEsque;
+        baseURL: string;
+        throw?: boolean | undefined;
+        auth?: ({
+            type: "Bearer";
+            token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+        } | {
+            type: "Basic";
+            username: string | (() => string | undefined) | undefined;
+            password: string | (() => string | undefined) | undefined;
+        } | {
+            type: "Custom";
+            prefix: string | (() => string | undefined) | undefined;
+            value: string | (() => string | undefined) | undefined;
+        }) | undefined;
+        body?: any;
+        query?: any;
+        params?: any;
+        duplex?: "full" | "half" | undefined;
+        jsonParser: (text: string) => Promise<any> | any;
+        retry?: import("@better-fetch/fetch").RetryOptions | undefined;
+        retryAttempt?: number | undefined;
+        output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+        errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
+        disableValidation?: boolean | undefined;
+    }, unknown, unknown, {}>;
+    $store: {
+        notify: (signal?: (Omit<string, "$sessionSignal"> | "$sessionSignal") | undefined) => void;
+        listen: (signal: Omit<string, "$sessionSignal"> | "$sessionSignal", listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
+        atoms: Record<string, WritableAtom<any>>;
+    };
+};

package/dist/src/client/fetch-plugins.d.ts

@@ -0,0 +1,14 @@
+export declare const redirectPlugin: {
+    id: string;
+    name: string;
+    hooks: {
+        onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): void;
+    };
+};
+export declare const userAgentPlugin: {
+    id: string;
+    name: string;
+    hooks: {
+        onRequest<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>): void;
+    };
+};

package/dist/src/client/index.d.ts

@@ -0,0 +1,15 @@
+import type { PayvoAuthOptions, PayvoAuthPlugin } from "@gatwech/core";
+export * from "./broadcast-channel";
+export * from "./query";
+export * from "./session-refresh";
+export * from "./types";
+export * from "./vanilla";
+export declare const InferPlugin: <T extends PayvoAuthPlugin>() => {
+    id: "infer-server-plugin";
+    $InferServerPlugin: T;
+};
+export declare function InferAuth<O extends {
+    options: PayvoAuthOptions;
+}>(): O["options"];
+export type * from "@better-fetch/fetch";
+export type * from "nanostores";

package/dist/src/client/parser.d.ts

@@ -0,0 +1,12 @@
+type ParseOptions = {
+    /** Throw errors instead of returning the original value */
+    strict?: boolean | undefined;
+    /** Log warnings when suspicious patterns are detected */
+    warnings?: boolean | undefined;
+    /** Custom reviver function */
+    reviver?: ((key: string, value: any) => any) | undefined;
+    /** Automatically convert ISO date strings to Date objects */
+    parseDates?: boolean | undefined;
+};
+export declare function parseJSON<T = unknown>(value: unknown, options?: ParseOptions): T;
+export default parseJSON;

package/dist/src/client/path-to-object.d.ts

@@ -0,0 +1,63 @@
+import type { PayvoAuthClientOptions } from "@gatwech/core";
+import type { BetterFetchOption, BetterFetchResponse } from "@better-fetch/fetch";
+import type { Endpoint, InputContext, StandardSchemaV1 } from "better-call";
+import type { HasRequiredKeys, Prettify, UnionToIntersection } from "../types/helper";
+import type { InferAdditionalFromClient, InferSessionFromClient, InferUserFromClient } from "./types";
+export type CamelCase<S extends string> = S extends `${infer P1}-${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : Lowercase<S>;
+export type PathToObject<T extends string, Fn extends (...args: any[]) => any> = T extends `/${infer Segment}/${infer Rest}` ? {
+    [K in CamelCase<Segment>]: PathToObject<`/${Rest}`, Fn>;
+} : T extends `/${infer Segment}` ? {
+    [K in CamelCase<Segment>]: Fn;
+} : never;
+export type InferSignUpEmailCtx<ClientOpts extends PayvoAuthClientOptions, FetchOptions extends BetterFetchOption> = {
+    email: string;
+    name: string;
+    password: string;
+    image?: string | undefined;
+    callbackURL?: string | undefined;
+    fetchOptions?: FetchOptions | undefined;
+} & UnionToIntersection<InferAdditionalFromClient<ClientOpts, "user", "input">>;
+export type InferUserUpdateCtx<ClientOpts extends PayvoAuthClientOptions, FetchOptions extends BetterFetchOption> = {
+    image?: (string | null) | undefined;
+    name?: string | undefined;
+    fetchOptions?: FetchOptions | undefined;
+} & Partial<UnionToIntersection<InferAdditionalFromClient<ClientOpts, "user", "input">>>;
+export type InferCtx<C extends InputContext<any, any>, FetchOptions extends BetterFetchOption> = C["body"] extends Record<string, any> ? C["body"] & {
+    fetchOptions?: FetchOptions | undefined;
+} : C["query"] extends Record<string, any> ? {
+    query: C["query"];
+    fetchOptions?: FetchOptions | undefined;
+} : C["query"] extends Record<string, any> | undefined ? {
+    query?: C["query"] | undefined;
+    fetchOptions?: FetchOptions | undefined;
+} : {
+    fetchOptions?: FetchOptions | undefined;
+};
+export type MergeRoutes<T> = UnionToIntersection<T>;
+export type InferRoute<API, COpts extends PayvoAuthClientOptions> = API extends Record<string, infer T> ? T extends Endpoint ? T["options"]["metadata"] extends {
+    isAction: false;
+} | {
+    SERVER_ONLY: true;
+} ? {} : PathToObject<T["path"], T extends (ctx: infer C) => infer R ? C extends InputContext<any, any> ? <FetchOptions extends BetterFetchOption<Partial<C["body"]> & Record<string, any>, Partial<C["query"]> & Record<string, any>, C["params"]>>(...data: HasRequiredKeys<InferCtx<C, FetchOptions>> extends true ? [
+    Prettify<T["path"] extends `/sign-up/email` ? InferSignUpEmailCtx<COpts, FetchOptions> : InferCtx<C, FetchOptions>>,
+    FetchOptions?
+] : [
+    Prettify<T["path"] extends `/update-user` ? InferUserUpdateCtx<COpts, FetchOptions> : InferCtx<C, FetchOptions>>?,
+    FetchOptions?
+]) => Promise<BetterFetchResponse<T["options"]["metadata"] extends {
+    CUSTOM_SESSION: boolean;
+} ? NonNullable<Awaited<R>> : T["path"] extends "/get-session" ? {
+    user: InferUserFromClient<COpts>;
+    session: InferSessionFromClient<COpts>;
+} | null : NonNullable<Awaited<R>>, T["options"]["error"] extends StandardSchemaV1 ? NonNullable<T["options"]["error"]["~standard"]["types"]>["output"] : {
+    code?: string | undefined;
+    message?: string | undefined;
+}, FetchOptions["throw"] extends true ? true : COpts["fetchOptions"] extends {
+    throw: true;
+} ? true : false>> : never : never> : {} : never;
+export type InferRoutes<API extends Record<string, Endpoint>, ClientOpts extends PayvoAuthClientOptions> = MergeRoutes<InferRoute<API, ClientOpts>>;
+export type ProxyRequest = {
+    options?: BetterFetchOption<any, any> | undefined;
+    query?: any | undefined;
+    [key: string]: any;
+};

package/dist/src/client/plugins/index.d.ts

@@ -0,0 +1,21 @@
+export type * from "../../types/helper";
+export * from "../../plugins/additional-fields/client";
+export * from "../../plugins/admin/client";
+export * from "../../plugins/anonymous/client";
+export * from "../../plugins/api-key/client";
+export * from "../../plugins/custom-session/client";
+export * from "../../plugins/device-authorization/client";
+export * from "../../plugins/email-otp/client";
+export * from "../../plugins/generic-oauth/client";
+export * from "../../plugins/jwt/client";
+export * from "../../plugins/last-login-method/client";
+export * from "../../plugins/magic-link/client";
+export * from "../../plugins/multi-session/client";
+export * from "../../plugins/one-tap/client";
+export * from "../../plugins/one-time-token/client";
+export * from "../../plugins/organization/client";
+export * from "../../plugins/phone-number/client";
+export * from "../../plugins/two-factor/client";
+export * from "../../plugins/passkey/client";
+export * from "../../plugins/username/client";
+export * from "./infer-plugin";

package/dist/src/client/plugins/infer-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { PayvoAuthOptions } from "@gatwech/core";
+export declare const InferServerPlugin: <AuthOrOption extends PayvoAuthOptions | {
+    options: PayvoAuthOptions;
+}, ID extends string>() => {
+    id: "infer-server-plugin";
+    $InferServerPlugin: (AuthOrOption extends {
+        options: infer O;
+    } ? O : AuthOrOption)["plugins"] extends (infer P)[] ? P extends {
+        id: ID;
+    } ? P : never : never;
+};

package/dist/src/client/proxy.d.ts

@@ -0,0 +1,8 @@
+import type { PayvoAuthClientPlugin } from "@gatwech/core";
+import type { BetterFetch } from "@better-fetch/fetch";
+import type { Atom, PreinitializedWritableAtom } from "nanostores";
+export type AuthProxySignal = {
+    atom: PreinitializedWritableAtom<boolean>;
+    matcher: (path: string) => boolean;
+};
+export declare function createDynamicPathProxy<T extends Record<string, any>>(routes: T, client: BetterFetch, knownPathMethods: Record<string, "POST" | "GET">, atoms: Record<string, Atom>, atomListeners: PayvoAuthClientPlugin["atomListeners"]): T;

package/dist/src/client/query.d.ts

@@ -0,0 +1,16 @@
+import { type BetterFetch, BetterFetchError, type BetterFetchOption } from "@better-fetch/fetch";
+import { type PreinitializedWritableAtom } from "nanostores";
+import type { SessionQueryParams } from "./types";
+export declare const useAuthQuery: <T>(initializedAtom: PreinitializedWritableAtom<any> | PreinitializedWritableAtom<any>[], path: string, $fetch: BetterFetch, options?: (((value: {
+    data: null | T;
+    error: null | BetterFetchError;
+    isPending: boolean;
+}) => BetterFetchOption) | BetterFetchOption) | undefined) => PreinitializedWritableAtom<{
+    data: null | T;
+    error: null | BetterFetchError;
+    isPending: boolean;
+    isRefetching: boolean;
+    refetch: (queryParams?: {
+        query?: SessionQueryParams;
+    } | undefined) => void;
+}> & object;

package/dist/src/client/react/index.d.ts

@@ -0,0 +1,130 @@
+import type { PayvoAuthClientOptions, PayvoAuthClientPlugin } from "@gatwech/core";
+import type { BASE_ERROR_CODES } from "@gatwech/core/error";
+import type { BetterFetchError } from "@better-fetch/fetch";
+import type { PrettifyDeep, UnionToIntersection } from "../../types/helper";
+import type { InferActions, InferClientAPI, InferErrorCodes, IsSignal, SessionQueryParams } from "../types";
+import { useStore } from "./react-store";
+export declare function capitalizeFirstLetter(str: string): string;
+type InferResolvedHooks<O extends PayvoAuthClientOptions> = O extends {
+    plugins: Array<infer Plugin>;
+} ? UnionToIntersection<Plugin extends PayvoAuthClientPlugin ? Plugin["getAtoms"] extends (fetch: any) => infer Atoms ? Atoms extends Record<string, any> ? {
+    [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: () => ReturnType<Atoms[key]["get"]>;
+} : {} : {} : {}> : {};
+export declare function createAuthClient<Option extends PayvoAuthClientOptions>(options?: Option | undefined): UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+    useSession: () => {
+        data: InferClientAPI<Option> extends {
+            getSession: () => Promise<infer Res>;
+        } ? Res extends {
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | {
+            data: infer S;
+            error: null;
+        } ? S : Res : never;
+        isPending: boolean;
+        isRefetching: boolean;
+        error: BetterFetchError | null;
+        refetch: (queryParams?: {
+            query?: SessionQueryParams;
+        } | undefined) => void;
+    };
+    $Infer: {
+        Session: NonNullable<InferClientAPI<Option> extends {
+            getSession: () => Promise<infer Res>;
+        } ? Res extends {
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | {
+            data: infer S;
+            error: null;
+        } ? S : Res : never>;
+    };
+    $fetch: import("@better-fetch/fetch").BetterFetch<{
+        plugins: (import("@better-fetch/fetch").BetterFetchPlugin | {
+            id: string;
+            name: string;
+            hooks: {
+                onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): void;
+            };
+        } | {
+            id: string;
+            name: string;
+            hooks: {
+                onRequest<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>): void;
+            };
+        } | {
+            id: string;
+            name: string;
+            hooks: {
+                onSuccess: ((context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void> | void) | undefined;
+                onError: ((context: import("@better-fetch/fetch").ErrorContext) => Promise<void> | void) | undefined;
+                onRequest: (<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>) => Promise<import("@better-fetch/fetch").RequestContext | void> | import("@better-fetch/fetch").RequestContext | void) | undefined;
+                onResponse: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
+            };
+        })[];
+        method: string;
+        headers?: (HeadersInit & (HeadersInit | {
+            accept: "application/json" | "text/plain" | "application/octet-stream";
+            "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+            authorization: "Bearer" | "Basic";
+        })) | undefined;
+        redirect?: RequestRedirect | undefined;
+        cache?: RequestCache | undefined;
+        credentials?: RequestCredentials;
+        integrity?: string | undefined;
+        keepalive?: boolean | undefined;
+        mode?: RequestMode | undefined;
+        priority?: RequestPriority | undefined;
+        referrer?: string | undefined;
+        referrerPolicy?: ReferrerPolicy | undefined;
+        signal?: (AbortSignal | null) | undefined;
+        window?: null | undefined;
+        onRetry?: ((response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void) | undefined;
+        hookOptions?: {
+            cloneResponse?: boolean;
+        } | undefined;
+        timeout?: number | undefined;
+        customFetchImpl: import("@better-fetch/fetch").FetchEsque;
+        baseURL: string;
+        throw?: boolean | undefined;
+        auth?: ({
+            type: "Bearer";
+            token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+        } | {
+            type: "Basic";
+            username: string | (() => string | undefined) | undefined;
+            password: string | (() => string | undefined) | undefined;
+        } | {
+            type: "Custom";
+            prefix: string | (() => string | undefined) | undefined;
+            value: string | (() => string | undefined) | undefined;
+        }) | undefined;
+        body?: any;
+        query?: any;
+        params?: any;
+        duplex?: "full" | "half" | undefined;
+        jsonParser: (text: string) => Promise<any> | any;
+        retry?: import("@better-fetch/fetch").RetryOptions | undefined;
+        retryAttempt?: number | undefined;
+        output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+        errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
+        disableValidation?: boolean | undefined;
+    }, unknown, unknown, {}>;
+    $store: {
+        notify: (signal?: (Omit<string, "$sessionSignal"> | "$sessionSignal") | undefined) => void;
+        listen: (signal: Omit<string, "$sessionSignal"> | "$sessionSignal", listener: (value: boolean, oldValue?: boolean | undefined) => void) => void;
+        atoms: Record<string, import("nanostores").WritableAtom<any>>;
+    };
+    $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
+};
+export { useStore };
+export type * from "@better-fetch/fetch";
+export type * from "nanostores";

package/dist/src/client/react/react-store.d.ts

@@ -0,0 +1,43 @@
+import type { Store, StoreValue } from "nanostores";
+import type { DependencyList } from "react";
+type StoreKeys<T> = T extends {
+    setKey: (k: infer K, v: any) => unknown;
+} ? K : never;
+export interface UseStoreOptions<SomeStore> {
+    /**
+     * @default
+     * ```ts
+     * [store, options.keys]
+     * ```
+     */
+    deps?: DependencyList | undefined;
+    /**
+     * Will re-render components only on specific key changes.
+     */
+    keys?: StoreKeys<SomeStore>[] | undefined;
+}
+/**
+ * Subscribe to store changes and get store's value.
+ *
+ * Can be used with store builder too.
+ *
+ * ```js
+ * import { useStore } from 'nanostores/react'
+ *
+ * import { router } from '../store/router'
+ *
+ * export const Layout = () => {
+ *   let page = useStore(router)
+ *   if (page.route === 'home') {
+ *     return <HomePage />
+ *   } else {
+ *     return <Error404 />
+ *   }
+ * }
+ * ```
+ *
+ * @param store Store instance.
+ * @returns Store value.
+ */
+export declare function useStore<SomeStore extends Store>(store: SomeStore, options?: UseStoreOptions<SomeStore>): StoreValue<SomeStore>;
+export {};

package/dist/src/client/session-atom.d.ts

@@ -0,0 +1,18 @@
+import type { PayvoAuthClientOptions } from "@gatwech/core";
+import type { BetterFetch } from "@better-fetch/fetch";
+import type { Session, User } from "../types";
+export declare function getSessionAtom($fetch: BetterFetch, options?: PayvoAuthClientOptions | undefined): {
+    session: import("nanostores").PreinitializedWritableAtom<{
+        data: {
+            user: User;
+            session: Session;
+        } | null;
+        error: null | import("@better-fetch/fetch").BetterFetchError;
+        isPending: boolean;
+        isRefetching: boolean;
+        refetch: (queryParams?: {
+            query?: import("./types").SessionQueryParams;
+        } | undefined) => void;
+    }> & object;
+    $sessionSignal: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+};

package/dist/src/client/session-refresh.d.ts

@@ -0,0 +1,17 @@
+import type { PayvoAuthClientOptions } from "@gatwech/core";
+import type { BetterFetch } from "@better-fetch/fetch";
+import type { WritableAtom } from "nanostores";
+export interface SessionRefreshOptions {
+    sessionAtom: WritableAtom<any>;
+    sessionSignal: WritableAtom<boolean>;
+    $fetch: BetterFetch;
+    options?: PayvoAuthClientOptions | undefined;
+}
+export declare function createSessionRefreshManager(opts: SessionRefreshOptions): {
+    init: () => void;
+    cleanup: () => void;
+    triggerRefetch: (event?: {
+        event?: "poll" | "visibilitychange" | "storage";
+    } | undefined) => void;
+    broadcastSessionUpdate: (trigger: "signout" | "getSession" | "updateUser") => void;
+};

package/dist/src/client/test-plugin.d.ts

@@ -0,0 +1,147 @@
+import z from "zod";
+declare const serverPlugin: {
+    id: "test";
+    endpoints: {
+        test: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                body?: undefined;
+            } & {
+                method?: "GET" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: import("better-call").Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    data: string;
+                };
+            } : {
+                data: string;
+            }>;
+            options: {
+                method: "GET";
+                error: z.ZodObject<{
+                    code: z.ZodNumber;
+                    message: z.ZodString;
+                    test: z.ZodBoolean;
+                }, z.core.$strip>;
+            } & {
+                use: any[];
+            };
+            path: "/test";
+        };
+        testSignOut2: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                body?: undefined;
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: import("better-call").Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: null;
+            } : null>;
+            options: {
+                method: "POST";
+            } & {
+                use: any[];
+            };
+            path: "/test-2/sign-out";
+        };
+    };
+    schema: {
+        user: {
+            fields: {
+                testField: {
+                    type: "string";
+                    required: false;
+                };
+                testField2: {
+                    type: "number";
+                    required: false;
+                };
+                testField3: {
+                    type: "string";
+                    returned: false;
+                };
+                testField4: {
+                    type: "string";
+                    defaultValue: string;
+                };
+            };
+        };
+    };
+};
+export declare const testClientPlugin: () => {
+    id: "test";
+    getActions($fetch: import("@better-fetch/fetch").BetterFetch): {
+        setTestAtom(value: boolean): void;
+        test: {
+            signOut: () => Promise<void>;
+        };
+    };
+    getAtoms($fetch: import("@better-fetch/fetch").BetterFetch): {
+        $test: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+        $signal: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+        computedAtom: import("nanostores").ReadableAtom<number>;
+        queryAtom: import("nanostores").PreinitializedWritableAtom<{
+            data: any;
+            error: null | import("@better-fetch/fetch").BetterFetchError;
+            isPending: boolean;
+            isRefetching: boolean;
+            refetch: (queryParams?: {
+                query?: import("./types").SessionQueryParams;
+            } | undefined) => void;
+        }> & object;
+    };
+    $InferServerPlugin: typeof serverPlugin;
+    atomListeners: ({
+        matcher: (path: string) => path is "/test";
+        signal: "$test";
+    } | {
+        matcher: (path: string) => path is "/test2/sign-out";
+        signal: "$sessionSignal";
+    })[];
+};
+export declare const testClientPlugin2: () => {
+    id: "test";
+    getAtoms($fetch: import("@better-fetch/fetch").BetterFetch): {
+        $test2: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+        anotherAtom: import("nanostores").ReadableAtom<number>;
+    };
+    atomListeners: ({
+        matcher: (path: string) => path is "/test";
+        signal: "$test";
+    } | {
+        matcher: (path: string) => path is "/test2/sign-out";
+        signal: "$sessionSignal";
+    })[];
+};
+export {};