@rebasepro/client 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/dist/admin.d.ts

@@ -13,8 +13,8 @@ export interface RebaseRole {
     id: string;
     name: string;
     isAdmin: boolean;
-    defaultPermissions: Record<string, any> | null;
-    config: Record<string, any> | null;
+    defaultPermissions: Record<string, unknown> | null;
+    config: Record<string, unknown> | null;
 }
 export interface CreateAdminOptions {
     adminPath?: string;
@@ -67,16 +67,16 @@ export declare function createAdmin(transport: Transport, options?: CreateAdminO
         id: string;
         name: string;
         isAdmin?: boolean;
-        defaultPermissions?: any;
-        config?: any;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
     }) => Promise<{
         role: RebaseRole;
     }>;
     updateRole: (roleId: string, data: {
         name?: string;
         isAdmin?: boolean;
-        defaultPermissions?: any;
-        config?: any;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
     }) => Promise<{
         role: RebaseRole;
     }>;

package/dist/auth.d.ts

@@ -20,7 +20,7 @@ export interface RebaseSession {
     expiresAt: number;
     user: RebaseUser;
 }
-export type AuthChangeEvent = 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED';
+export type AuthChangeEvent = "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "USER_UPDATED";
 export interface AuthConfig {
     needsSetup: boolean;
     registrationEnabled: boolean;
@@ -55,6 +55,72 @@ export declare function createAuth(transport: Transport, options?: CreateAuthOpt
         accessToken: string;
         refreshToken: string;
     }>;
+    signInWithLinkedin: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithOAuth: (providerId: string, payload: Record<string, unknown>) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithGitHub: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithMicrosoft: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithApple: (code: string, redirectUri: string, user?: {
+        name?: {
+            firstName?: string;
+            lastName?: string;
+        };
+        email?: string;
+    }) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithFacebook: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithTwitter: (code: string, redirectUri: string, codeVerifier: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithDiscord: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithGitLab: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithBitbucket: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithSlack: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithSpotify: (code: string, redirectUri: string) => Promise<{
+        user: RebaseUser;
+        accessToken: string;
+        refreshToken: string;
+    }>;
     signOut: () => Promise<void>;
     refreshSession: () => Promise<RebaseSession>;
     getUser: () => Promise<RebaseUser>;

package/dist/collection.d.ts

@@ -8,12 +8,12 @@ import { FilterOperator, QueryBuilder } from "./query_builder";
  *
  * Additionally it exposes fluent query builder methods like `.where()`, `.orderBy()`.
  */
-export interface CollectionClient<M extends Record<string, any> = any> extends CollectionAccessor<M> {
-    where(column: keyof M & string, operator: FilterOperator, value: any): QueryBuilder<M>;
+export interface CollectionClient<M extends Record<string, unknown> = Record<string, unknown>> extends CollectionAccessor<M> {
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): QueryBuilder<M>;
     orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilder<M>;
     limit(count: number): QueryBuilder<M>;
     offset(count: number): QueryBuilder<M>;
     search(searchString: string): QueryBuilder<M>;
     include(...relations: string[]): QueryBuilder<M>;
 }
-export declare function createCollectionClient<M extends Record<string, any> = any>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M>;
+export declare function createCollectionClient<M extends Record<string, unknown> = Record<string, unknown>>(transport: Transport, slug: string, ws?: RebaseWebSocketClient): CollectionClient<M>;

package/dist/cron.d.ts

@@ -0,0 +1,25 @@
+import { Transport } from "./transport";
+import type { CronJobStatus, CronJobLogEntry } from "@rebasepro/types";
+export interface CreateCronOptions {
+    cronPath?: string;
+}
+export declare function createCron(transport: Transport, options?: CreateCronOptions): {
+    listJobs: () => Promise<{
+        jobs: CronJobStatus[];
+    }>;
+    getJob: (jobId: string) => Promise<{
+        job: CronJobStatus;
+    }>;
+    triggerJob: (jobId: string) => Promise<{
+        log: CronJobLogEntry;
+        job: CronJobStatus;
+    }>;
+    getJobLogs: (jobId: string, options?: {
+        limit?: number;
+    }) => Promise<{
+        logs: CronJobLogEntry[];
+    }>;
+    toggleJob: (jobId: string, enabled: boolean) => Promise<{
+        job: CronJobStatus;
+    }>;
+};

package/dist/cron.test.d.ts

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

package/dist/index.d.ts

@@ -1,37 +1,42 @@
 import { RebaseClientConfig } from "./transport";
 import { createAuth, CreateAuthOptions } from "./auth";
 import { createAdmin, CreateAdminOptions } from "./admin";
+import { createCron, CreateCronOptions } from "./cron";
 import { CollectionClient } from "./collection";
 export * from "./transport";
 export * from "./auth";
 export * from "./admin";
+export * from "./cron";
 export * from "./collection";
 export * from "./websocket";
 export * from "./storage";
+export * from "./reviver";
 export interface CreateRebaseClientOptions extends RebaseClientConfig {
     auth?: CreateAuthOptions;
     admin?: CreateAdminOptions;
+    cron?: CreateCronOptions;
 }
 import { RebaseWebSocketClient } from "./websocket";
 import { RebaseClient as BaseRebaseClient, RebaseData, StorageSource } from "@rebasepro/types";
-export type RebaseClient<DB = any> = BaseRebaseClient<DB> & {
+export type RebaseClient<DB = Record<string, unknown>> = BaseRebaseClient<DB> & {
     setToken: (token: string | null) => void;
     setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
     setOnUnauthorized: (handler: () => Promise<boolean>) => void;
     resolveToken: () => Promise<string | null>;
     auth: ReturnType<typeof createAuth>;
     admin: ReturnType<typeof createAdmin>;
+    cron: ReturnType<typeof createCron>;
     ws?: RebaseWebSocketClient;
     storage?: StorageSource;
-    call: <T = any>(endpoint: string, payload?: any) => Promise<T>;
+    call: <T = unknown>(endpoint: string, payload?: unknown) => Promise<T>;
     data: RebaseData & {
         collection<K extends keyof DB>(slug: Extract<K, string>): CollectionClient<DB[K] extends {
-            Row: infer R extends Record<string, any>;
-        } ? R : any>;
+            Row: infer R extends Record<string, unknown>;
+        } ? R : Record<string, unknown>>;
     } & {
         [K in keyof DB]: CollectionClient<DB[K] extends {
-            Row: infer R extends Record<string, any>;
-        } ? R : any>;
+            Row: infer R extends Record<string, unknown>;
+        } ? R : Record<string, unknown>>;
     };
 };
-export declare function createRebaseClient<DB = any>(options: CreateRebaseClientOptions): RebaseClient<DB>;
+export declare function createRebaseClient<DB = Record<string, unknown>>(options: CreateRebaseClientOptions): RebaseClient<DB>;