wabe 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,921 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { Wobe, WobeHandler, WobeResponse } from 'wobe';
+
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+	ID: {
+		input: string;
+		output: string;
+	};
+	String: {
+		input: string;
+		output: string;
+	};
+	Boolean: {
+		input: boolean;
+		output: boolean;
+	};
+	Int: {
+		input: number;
+		output: number;
+	};
+	Float: {
+		input: number;
+		output: number;
+	};
+	/** Phone custom scalar type */
+	Phone: {
+		input: any;
+		output: any;
+	};
+	/** Date scalar type */
+	Date: {
+		input: any;
+		output: any;
+	};
+	/** Email scalar type */
+	Email: {
+		input: any;
+		output: any;
+	};
+	/** File scalar type */
+	File: {
+		input: any;
+		output: any;
+	};
+	/** Search scalar to tokenize and search for all searchable fields */
+	Search: {
+		input: any;
+		output: any;
+	};
+	/** The Any scalar type is used in operations and types that involve any type of value. */
+	Any: {
+		input: any;
+		output: any;
+	};
+};
+declare enum AuthenticationProvider {
+	Google = "Google"
+}
+declare enum SecondaryFactor {
+	EmailOtp = "EmailOTP"
+}
+/** User class */
+export type User = {
+	__typename?: "User";
+	id: Scalars["ID"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	age?: Maybe<Scalars["Int"]["output"]>;
+	acl?: Maybe<UserAclObject>;
+	createdAt?: Maybe<Scalars["Date"]["output"]>;
+	updatedAt?: Maybe<Scalars["Date"]["output"]>;
+	search?: Maybe<Array<Maybe<Scalars["String"]["output"]>>>;
+	authentication?: Maybe<UserAuthentication>;
+	provider?: Maybe<AuthenticationProvider>;
+	isOauth?: Maybe<Scalars["Boolean"]["output"]>;
+	email?: Maybe<Scalars["Email"]["output"]>;
+	verifiedEmail?: Maybe<Scalars["Boolean"]["output"]>;
+	role?: Maybe<Role>;
+	sessions?: Maybe<_SessionConnection>;
+};
+export type UserAclObject = {
+	__typename?: "UserACLObject";
+	users?: Maybe<Array<Maybe<UserAclObjectUsersAcl>>>;
+	roles?: Maybe<Array<Maybe<UserAclObjectRolesAcl>>>;
+};
+export type UserAclObjectUsersAcl = {
+	__typename?: "UserACLObjectUsersACL";
+	userId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type UserAclObjectRolesAcl = {
+	__typename?: "UserACLObjectRolesACL";
+	roleId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type UserAuthentication = {
+	__typename?: "UserAuthentication";
+	emailPassword?: Maybe<UserAuthenticationEmailPassword>;
+	google?: Maybe<UserAuthenticationGoogle>;
+};
+export type UserAuthenticationEmailPassword = {
+	__typename?: "UserAuthenticationEmailPassword";
+	email: Scalars["Email"]["output"];
+	password: Scalars["String"]["output"];
+};
+export type UserAuthenticationGoogle = {
+	__typename?: "UserAuthenticationGoogle";
+	email: Scalars["Email"]["output"];
+	verifiedEmail: Scalars["Boolean"]["output"];
+	idToken: Scalars["String"]["output"];
+};
+export type _SessionConnection = {
+	__typename?: "_SessionConnection";
+	totalCount?: Maybe<Scalars["Int"]["output"]>;
+	edges?: Maybe<Array<Maybe<_SessionEdge>>>;
+};
+export type _SessionEdge = {
+	__typename?: "_SessionEdge";
+	node: _Session;
+};
+export type Post = {
+	__typename?: "Post";
+	id: Scalars["ID"]["output"];
+	name: Scalars["String"]["output"];
+	test?: Maybe<Scalars["File"]["output"]>;
+	acl?: Maybe<PostAclObject>;
+	createdAt?: Maybe<Scalars["Date"]["output"]>;
+	updatedAt?: Maybe<Scalars["Date"]["output"]>;
+	search?: Maybe<Array<Maybe<Scalars["String"]["output"]>>>;
+};
+export type PostAclObject = {
+	__typename?: "PostACLObject";
+	users?: Maybe<Array<Maybe<PostAclObjectUsersAcl>>>;
+	roles?: Maybe<Array<Maybe<PostAclObjectRolesAcl>>>;
+};
+export type PostAclObjectUsersAcl = {
+	__typename?: "PostACLObjectUsersACL";
+	userId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type PostAclObjectRolesAcl = {
+	__typename?: "PostACLObjectRolesACL";
+	roleId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type _Session = {
+	__typename?: "_Session";
+	id: Scalars["ID"]["output"];
+	user?: Maybe<User>;
+	accessToken: Scalars["String"]["output"];
+	accessTokenExpiresAt: Scalars["Date"]["output"];
+	refreshToken?: Maybe<Scalars["String"]["output"]>;
+	refreshTokenExpiresAt: Scalars["Date"]["output"];
+	acl?: Maybe<_SessionAclObject>;
+	createdAt?: Maybe<Scalars["Date"]["output"]>;
+	updatedAt?: Maybe<Scalars["Date"]["output"]>;
+	search?: Maybe<Array<Maybe<Scalars["String"]["output"]>>>;
+};
+export type _SessionAclObject = {
+	__typename?: "_SessionACLObject";
+	users?: Maybe<Array<Maybe<_SessionAclObjectUsersAcl>>>;
+	roles?: Maybe<Array<Maybe<_SessionAclObjectRolesAcl>>>;
+};
+export type _SessionAclObjectUsersAcl = {
+	__typename?: "_SessionACLObjectUsersACL";
+	userId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type _SessionAclObjectRolesAcl = {
+	__typename?: "_SessionACLObjectRolesACL";
+	roleId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type Role = {
+	__typename?: "Role";
+	id: Scalars["ID"]["output"];
+	name: Scalars["String"]["output"];
+	users?: Maybe<UserConnection>;
+	acl?: Maybe<RoleAclObject>;
+	createdAt?: Maybe<Scalars["Date"]["output"]>;
+	updatedAt?: Maybe<Scalars["Date"]["output"]>;
+	search?: Maybe<Array<Maybe<Scalars["String"]["output"]>>>;
+};
+export type UserConnection = {
+	__typename?: "UserConnection";
+	totalCount?: Maybe<Scalars["Int"]["output"]>;
+	edges?: Maybe<Array<Maybe<UserEdge>>>;
+};
+export type UserEdge = {
+	__typename?: "UserEdge";
+	node: User;
+};
+export type RoleAclObject = {
+	__typename?: "RoleACLObject";
+	users?: Maybe<Array<Maybe<RoleAclObjectUsersAcl>>>;
+	roles?: Maybe<Array<Maybe<RoleAclObjectRolesAcl>>>;
+};
+export type RoleAclObjectUsersAcl = {
+	__typename?: "RoleACLObjectUsersACL";
+	userId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type RoleAclObjectRolesAcl = {
+	__typename?: "RoleACLObjectRolesACL";
+	roleId: Scalars["String"]["output"];
+	read: Scalars["Boolean"]["output"];
+	write: Scalars["Boolean"]["output"];
+};
+export type SignInWithInput = {
+	authentication?: InputMaybe<SignInWithAuthenticationInput>;
+};
+export type SignInWithAuthenticationInput = {
+	emailPassword?: InputMaybe<SignInWithAuthenticationEmailPasswordInput>;
+	google?: InputMaybe<SignInWithAuthenticationGoogleInput>;
+	otp?: InputMaybe<SignInWithAuthenticationOtpInput>;
+	secondaryFactor?: InputMaybe<SecondaryFactor>;
+};
+export type SignInWithAuthenticationEmailPasswordInput = {
+	email: Scalars["Email"]["input"];
+	password: Scalars["String"]["input"];
+};
+export type SignInWithAuthenticationGoogleInput = {
+	authorizationCode: Scalars["String"]["input"];
+	codeVerifier: Scalars["String"]["input"];
+};
+export type SignInWithAuthenticationOtpInput = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type SignUpWithInput = {
+	authentication?: InputMaybe<SignUpWithAuthenticationInput>;
+};
+export type SignUpWithAuthenticationInput = {
+	emailPassword?: InputMaybe<SignUpWithAuthenticationEmailPasswordInput>;
+	google?: InputMaybe<SignUpWithAuthenticationGoogleInput>;
+	otp?: InputMaybe<SignUpWithAuthenticationOtpInput>;
+	secondaryFactor?: InputMaybe<SecondaryFactor>;
+};
+export type SignUpWithAuthenticationEmailPasswordInput = {
+	email: Scalars["Email"]["input"];
+	password: Scalars["String"]["input"];
+};
+export type SignUpWithAuthenticationGoogleInput = {
+	authorizationCode: Scalars["String"]["input"];
+	codeVerifier: Scalars["String"]["input"];
+};
+export type SignUpWithAuthenticationOtpInput = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type WabeSchemaScalars = "Phone";
+export type WabeSchemaEnums = "AuthenticationProvider" | "SecondaryFactor";
+export type WabeSchemaTypes = {
+	User: User;
+	Post: Post;
+	_Session: _Session;
+	Role: Role;
+};
+export interface WabeContext<T extends WabeTypes> {
+	response?: WobeResponse;
+	user?: User | null;
+	sessionId?: string;
+	isRoot: boolean;
+	wabe: Wabe<T>;
+}
+export type WhereAggregation<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]> = Record<K | "id", {
+	equalTo?: any;
+	notEqualTo?: any;
+	greaterThan?: any;
+	lessThan?: any;
+	greaterThanOrEqualTo?: any;
+	lessThanOrEqualTo?: any;
+	in?: any[];
+	notIn?: any[];
+	contains?: any;
+	notContains?: any;
+}>;
+export type WhereConditional<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]> = {
+	OR?: Array<WhereType<T, K>>;
+	AND?: Array<WhereType<T, K>>;
+};
+export type WhereType<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]> = Partial<WhereAggregation<T, K>> & WhereConditional<T, K>;
+export interface AdapterOptions {
+	databaseUrl: string;
+	databaseName: string;
+}
+export type MutationData<T extends keyof WabeTypes["types"]> = Record<keyof WabeTypes["types"][T], any>;
+export interface CountOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]> {
+	className: T;
+	where?: WhereType<T, K>;
+	context: WabeContext<any>;
+}
+export interface GetObjectOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]> {
+	className: T;
+	id: string;
+	where?: WhereType<T, K>;
+	fields: Array<K | "*">;
+	context: WabeContext<any>;
+	skipHooks?: boolean;
+}
+export interface GetObjectsOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]> {
+	className: T;
+	where?: WhereType<T, W>;
+	fields: Array<K | "*">;
+	offset?: number;
+	first?: number;
+	context: WabeContext<any>;
+	skipHooks?: boolean;
+}
+export interface CreateObjectOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]> {
+	className: T;
+	data: MutationData<W>;
+	fields: Array<K | "*">;
+	context: WabeContext<any>;
+}
+export interface CreateObjectsOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]> {
+	className: T;
+	data: Array<MutationData<W>>;
+	fields: Array<K | "*">;
+	offset?: number;
+	first?: number;
+	context: WabeContext<any>;
+}
+export interface UpdateObjectOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]> {
+	className: T;
+	id: string;
+	where?: WhereType<T, W>;
+	data: MutationData<W>;
+	fields: Array<K | "*">;
+	context: WabeContext<any>;
+}
+export interface UpdateObjectsOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]> {
+	className: T;
+	where: WhereType<T, W>;
+	data: MutationData<W>;
+	fields: Array<K | "*">;
+	offset?: number;
+	first?: number;
+	context: WabeContext<any>;
+}
+export interface DeleteObjectOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]> {
+	className: T;
+	id: string;
+	where?: WhereType<T, W>;
+	fields: Array<K | "*">;
+	context: WabeContext<any>;
+}
+export interface DeleteObjectsOptions<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]> {
+	className: T;
+	where: WhereType<T, W>;
+	fields: Array<K | "*">;
+	offset?: number;
+	first?: number;
+	context: WabeContext<any>;
+}
+export type OutputType<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]> = Pick<WabeTypes["types"][T], K> & {
+	id: string;
+};
+export interface DatabaseAdapter {
+	connect(): Promise<any>;
+	close(): Promise<any>;
+	createClassIfNotExist(className: string, context: WabeContext<any>): Promise<any>;
+	clearDatabase(): Promise<void>;
+	count<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]>(params: CountOptions<T, K>): Promise<number>;
+	getObject<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T]>(params: GetObjectOptions<T, K>): Promise<OutputType<T, K>>;
+	getObjects<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]>(params: GetObjectsOptions<T, K, W>): Promise<OutputType<T, K>[]>;
+	createObject<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]>(params: CreateObjectOptions<T, K, W>): Promise<OutputType<T, K>>;
+	createObjects<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]>(params: CreateObjectsOptions<T, K, W>): Promise<OutputType<T, K>[]>;
+	updateObject<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]>(params: UpdateObjectOptions<T, K, W>): Promise<OutputType<T, K>>;
+	updateObjects<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]>(params: UpdateObjectsOptions<T, K, W>): Promise<OutputType<T, K>[]>;
+	deleteObject<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]>(params: DeleteObjectOptions<T, K, W>): Promise<void>;
+	deleteObjects<T extends keyof WabeTypes["types"], K extends keyof WabeTypes["types"][T], W extends keyof WabeTypes["types"][T]>(params: DeleteObjectsOptions<T, K, W>): Promise<void>;
+}
+export declare const buildMongoWhereQuery: <T extends unknown, K extends keyof Record<any, any>[T]>(where?: WhereType<T, K>) => Record<string, any>;
+export declare class MongoAdapter<T extends WabeTypes> implements DatabaseAdapter {
+	options: AdapterOptions;
+	database?: Db;
+	private client;
+	constructor(options: AdapterOptions);
+	connect(): Promise<MongoClient>;
+	close(): Promise<void>;
+	createClassIfNotExist(className: keyof T["types"], context: WabeContext<T>): Promise<import("mongodb").Collection<import("bson").Document>>;
+	count<U extends keyof T["types"], K extends keyof T["types"][U]>(params: CountOptions<U, K>): Promise<number>;
+	clearDatabase(): Promise<void>;
+	getObject<U extends keyof T["types"], K extends keyof T["types"][U]>(params: GetObjectOptions<U, K>): Promise<OutputType<U, K>>;
+	getObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>(params: GetObjectsOptions<U, K, W>): Promise<OutputType<U, K>[]>;
+	createObject<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>(params: CreateObjectOptions<U, K, W>): Promise<OutputType<U, K>>;
+	createObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>(params: CreateObjectsOptions<U, K, W>): Promise<OutputType<U, K>[]>;
+	updateObject<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>(params: UpdateObjectOptions<U, K, W>): Promise<OutputType<U, K>>;
+	updateObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>(params: UpdateObjectsOptions<U, K, W>): Promise<OutputType<U, K>[]>;
+	deleteObject<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>(params: DeleteObjectOptions<U, K, W>): Promise<void>;
+	deleteObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>(params: DeleteObjectsOptions<U, K, W>): Promise<void>;
+}
+export interface InMemoryCacheOptions {
+	/**
+	 * Interval in ms to clear the cache
+	 */
+	interval: number;
+}
+declare class InMemoryCache<T> {
+	private options;
+	private store;
+	intervalId: Timer | undefined;
+	constructor(options: InMemoryCacheOptions);
+	_init(): void;
+	set(key: string, value: T): void;
+	get(key: string): T | undefined;
+	clear(): void;
+	stop(): void;
+}
+export type PointerObject = Record<string, {
+	pointerClass?: string;
+	fieldsOfPointerClass: Array<string>;
+}>;
+export interface PointerFields {
+	pointersFieldsId: string[];
+	pointers: PointerObject;
+}
+export declare class DatabaseController<T extends WabeTypes> {
+	adapter: DatabaseAdapter;
+	inMemoryCache: InMemoryCache<OutputType<any, any> | undefined>;
+	constructor(adapter: DatabaseAdapter);
+	connect(): Promise<any>;
+	close(): Promise<any>;
+	createClassIfNotExist(className: string, context: WabeContext<T>): Promise<any>;
+	_getPointerObject(className: keyof T["types"], fields: string[], context: WabeContext<T>): PointerFields;
+	_isRelationField<U extends keyof T["types"]>(originClassName: U, context: WabeContext<T>, pointerClassName?: string): boolean | undefined;
+	_isPointerField<U extends keyof T["types"]>(originClassName: U, context: WabeContext<T>, pointerClassName?: string): boolean | undefined;
+	_getFinalObjectWithPointer<U extends keyof T["types"], K extends keyof T["types"][U]>(objectData: OutputType<U, K> | null, pointersObject: PointerObject, originClassName: U, context: WabeContext<T>): Promise<Record<any, any>>;
+	_getWhereObjectWithPointerOrRelation<U extends keyof T["types"], K extends keyof T["types"][U]>(className: U, where: WhereType<U, K>, context: WabeContext<T>): Promise<Partial<{
+		[P in "id" | K]: {
+			equalTo?: any;
+			notEqualTo?: any;
+			greaterThan?: any;
+			lessThan?: any;
+			greaterThanOrEqualTo?: any;
+			lessThanOrEqualTo?: any;
+			in?: any[] | undefined;
+			notIn?: any[] | undefined;
+			contains?: any;
+			notContains?: any;
+		};
+	}> & {
+		OR?: WhereType<U, K>[] | undefined;
+		AND?: WhereType<U, K>[] | undefined;
+	}>;
+	_buildWhereWithACL<U extends keyof T["types"], K extends keyof T["types"][U]>(where: WhereType<U, K>, context: WabeContext<T>, operation: "write" | "read"): WhereType<U, K>;
+	_buildCacheKey<U extends keyof T["types"]>(className: U, id: string, fields: Array<string>): string;
+	count<U extends keyof T["types"], K extends keyof T["types"][U]>(params: CountOptions<U, K>): Promise<number>;
+	clearDatabase(): Promise<void>;
+	getObject<U extends keyof T["types"], K extends keyof T["types"][U]>({ fields, className, context, skipHooks, id, where, }: GetObjectOptions<U, K>): Promise<OutputType<U, K>>;
+	getObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>({ className, fields, context, where, skipHooks, first, offset, }: GetObjectsOptions<U, K, W>): Promise<OutputType<U, K>[]>;
+	createObject<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>({ className, context, data, fields }: CreateObjectOptions<U, K, W>): Promise<OutputType<U, K>>;
+	createObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>({ data, fields, className, context, first, offset, }: CreateObjectsOptions<U, K, W>): Promise<OutputType<U, K>[]>;
+	updateObject<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>({ id, className, context, data, fields }: UpdateObjectOptions<U, K, W>): Promise<OutputType<keyof T["types"], K>>;
+	updateObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>({ className, where, context, fields, data, first, offset, }: UpdateObjectsOptions<U, K, W>): Promise<OutputType<U, K>[]>;
+	deleteObject<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>({ context, className, id, fields }: DeleteObjectOptions<U, K, W>): Promise<OutputType<U, K>>;
+	deleteObjects<U extends keyof T["types"], K extends keyof T["types"][U], W extends keyof T["types"][U]>({ className, context, fields, where, first, offset, }: DeleteObjectsOptions<U, K, W>): Promise<OutputType<U, K>[]>;
+}
+export declare enum DatabaseEnum {
+	Mongo = "mongo"
+}
+export interface DatabaseConfig {
+	type: DatabaseEnum;
+	url: string;
+	name: string;
+}
+export type WabePrimaryTypes = "String" | "Int" | "Float" | "Boolean" | "Email" | "Date" | "File";
+export type WabeCustomTypes = "Array" | "Object";
+export type WabeRelationTypes = "Pointer" | "Relation";
+export type WabeFieldTypes = WabeCustomTypes | WabePrimaryTypes | WabeRelationTypes;
+export type WabeObject<T extends WabeTypes> = {
+	name: string;
+	fields: SchemaFields<T>;
+	description?: string;
+	required?: boolean;
+};
+export type TypeFieldBase<U, K extends WabeFieldTypes> = {
+	type: K;
+	required?: boolean;
+	description?: string;
+	defaultValue?: U;
+};
+export type TypeFieldArray<T extends WabeTypes> = {
+	type: "Array";
+	required?: boolean;
+	requiredValue?: boolean;
+	description?: string;
+	defaultValue?: any[];
+} & ({
+	typeValue: WabePrimaryTypes;
+} | {
+	typeValue: "Object";
+	object: WabeObject<T>;
+});
+export type TypeFieldObject<T extends WabeTypes> = {
+	type: "Object";
+	required?: boolean;
+	description?: string;
+	object: WabeObject<T>;
+	defaultValue?: any;
+};
+export type TypeFieldPointer<T extends WabeTypes> = {
+	type: "Pointer";
+	required?: boolean;
+	description?: string;
+	class: keyof T["types"];
+};
+export type TypeFieldRelation<T extends WabeTypes> = {
+	type: "Relation";
+	required?: boolean;
+	description?: string;
+	class: keyof T["types"];
+};
+export type TypeFieldFile = {
+	type: "File";
+	required?: boolean;
+	description?: string;
+};
+export type TypeFieldCustomScalars<T extends WabeTypes> = {
+	type: T["scalars"];
+	required?: boolean;
+	description?: string;
+	defaultValue?: any;
+};
+export type TypeFieldCustomEnums<T extends WabeTypes> = {
+	type: T["enums"];
+	required?: boolean;
+	description?: string;
+	defaultValue?: any;
+};
+export type TypeField<T extends WabeTypes> = TypeFieldBase<string, "String"> | TypeFieldBase<number, "Int"> | TypeFieldBase<number, "Float"> | TypeFieldBase<boolean, "Boolean"> | TypeFieldBase<Date, "Date"> | TypeFieldBase<string, "Email"> | TypeFieldArray<T> | TypeFieldObject<T> | TypeFieldPointer<T> | TypeFieldRelation<T> | TypeFieldFile | TypeFieldCustomScalars<T> | TypeFieldCustomEnums<T>;
+export type SchemaFields<T extends WabeTypes> = Record<string, TypeField<T>>;
+export type QueryResolver<T extends WabeTypes> = {
+	required?: boolean;
+	description?: string;
+	args?: SchemaFields<T>;
+	resolve: (...args: any) => any;
+} & ({
+	type: WabePrimaryTypes;
+} | {
+	type: "Object";
+	outputObject: ClassInterface<T>;
+} | {
+	type: "Array";
+	typeValue: WabePrimaryTypes;
+});
+export type MutationResolver<T extends WabeTypes> = {
+	required?: boolean;
+	description?: string;
+	args?: {
+		input: SchemaFields<T>;
+	};
+	resolve: (...args: any) => any;
+} & ({
+	type: WabePrimaryTypes;
+} | {
+	type: "Object";
+	outputObject: ClassInterface<T>;
+} | {
+	type: "Array";
+	typeValue: WabePrimaryTypes;
+});
+export type TypeResolver<T extends WabeTypes> = {
+	queries?: {
+		[key: string]: QueryResolver<T>;
+	};
+	mutations?: {
+		[key: string]: MutationResolver<T>;
+	};
+};
+export type PermissionsOperations = "create" | "read" | "update" | "delete";
+export interface PermissionProperties {
+	requireAuthentication?: boolean;
+	/**
+	 * An empty array means that none role is authorized (except root client)
+	 */
+	authorizedRoles?: Array<string>;
+}
+export type ClassPermissions = Partial<Record<PermissionsOperations, PermissionProperties>>;
+export type SearchableFields = Array<string>;
+export type ClassIndexes = Array<{
+	field: string;
+	order: "ASC" | "DESC";
+	unique?: boolean;
+}>;
+export interface ClassInterface<T extends WabeTypes> {
+	name: string;
+	fields: SchemaFields<T>;
+	description?: string;
+	permissions?: ClassPermissions;
+	searchableFields?: SearchableFields;
+	indexes?: ClassIndexes;
+}
+export interface ScalarInterface {
+	name: string;
+	description?: string;
+	parseValue?: (value: any) => any;
+	serialize?: (value: any) => any;
+	parseLiteral?: (ast: any) => any;
+}
+export interface EnumInterface {
+	name: string;
+	values: Record<string, string>;
+	description?: string;
+}
+export interface SchemaInterface<T extends WabeTypes> {
+	classes?: ClassInterface<T>[];
+	scalars?: ScalarInterface[];
+	enums?: EnumInterface[];
+	resolvers?: TypeResolver<T>;
+}
+export declare class Schema<T extends WabeTypes> {
+	schema: SchemaInterface<T>;
+	private config;
+	constructor(config: WabeConfig<T>);
+	defaultEnum(): EnumInterface[];
+	mergeResolvers(defaultResolvers: TypeResolver<T>): TypeResolver<T>;
+	defaultResolvers(): TypeResolver<T>;
+	sessionClass(): ClassInterface<T>;
+	roleClass(): ClassInterface<T>;
+	userClass(): ClassInterface<T>;
+	defaultFields(): SchemaFields<T>;
+	mergeClass(newClass: ClassInterface<T>[]): ClassInterface<T>[];
+	defaultClass(schema?: SchemaInterface<T>): ClassInterface<T>[];
+}
+export declare enum ProviderEnum {
+	google = "google",
+	x = "x"
+}
+export interface ProviderConfig {
+	clientId: string;
+	clientSecret: string;
+}
+export type AuthenticationEventsOptions<T> = {
+	input: T;
+	context: WabeContext<any>;
+};
+export type ProviderInterface<T = any> = {
+	onSignIn: (options: AuthenticationEventsOptions<T>) => Promise<{
+		user: Partial<User>;
+		oauth?: {
+			refreshToken: string;
+			accessToken: string;
+			accessTokenExpiresAt: Date;
+			refreshTokenExpiresAt: Date;
+		};
+	}>;
+	onSignUp: (options: AuthenticationEventsOptions<T>) => Promise<{
+		authenticationDataToSave: any;
+	}>;
+};
+export type SecondaryProviderInterface<T = any> = {
+	onSendChallenge: () => Promise<void>;
+	onVerifyChallenge: (options: T) => Promise<boolean>;
+};
+export type CustomAuthenticationMethods<T extends WabeTypes, U = ProviderInterface | SecondaryProviderInterface, K = SchemaFields<T>, W = SchemaFields<T>> = {
+	name: string;
+	input: K;
+	dataToStore?: W;
+	provider: U;
+	isSecondaryFactor?: boolean;
+};
+export type RoleConfig = Array<string>;
+export interface SessionConfig {
+	/**
+	 * The time in milliseconds that the access token will expire
+	 */
+	accessTokenExpiresIn?: number;
+	/**
+	 * The time in milliseconds that the refresh token will expire
+	 */
+	refreshTokenExpiresIn?: number;
+	/**
+	 * Set to true to automatically store the session tokens in cookies
+	 */
+	cookieSession?: boolean;
+}
+export interface AuthenticationConfig<T extends WabeTypes> {
+	session?: SessionConfig;
+	roles?: RoleConfig;
+	successRedirectPath?: string;
+	failureRedirectPath?: string;
+	providers?: Partial<Record<ProviderEnum, ProviderConfig>>;
+	customAuthenticationMethods?: CustomAuthenticationMethods<T>[];
+}
+export interface CreateTokenFromAuthorizationCodeOptions {
+	code: string;
+}
+export interface refreshTokenOptions {
+	refreshToken: string;
+}
+export interface Provider {
+	createTokenFromAuthorizationCode(options: CreateTokenFromAuthorizationCodeOptions): Promise<void>;
+	refreshToken(options: refreshTokenOptions): Promise<void>;
+}
+declare enum AuthenticationProvider$1 {
+	Google = "Google"
+}
+export interface WabeRoute {
+	method: "GET" | "POST" | "PUT" | "DELETE";
+	path: string;
+	handler: WobeHandler<WobeCustomContext<any>>;
+}
+declare class HookObject<T extends WabeTypes, K = keyof T["types"]> {
+	className: string;
+	private newData;
+	private operationType;
+	context: WabeContext<T>;
+	object: Record<keyof WabeTypes["types"][T], any>;
+	constructor({ newData, className, operationType, context, object, }: {
+		className: K;
+		newData?: MutationData<T>;
+		operationType: OperationType;
+		context: WabeContext<T>;
+		object: Record<keyof WabeTypes["types"][T], any>;
+	});
+	getUser(): User | null | undefined;
+	isFieldUpdate(field: keyof WabeTypes["types"][T]): boolean | undefined;
+	upsertNewData(field: keyof WabeTypes["types"][T], value: any): void;
+	getNewData(): MutationData<T>;
+}
+export declare enum OperationType {
+	AfterCreate = "AfterCreate",
+	AfterUpdate = "afterUpdate",
+	AfterDelete = "afterDelete",
+	AfterRead = "afterRead",
+	BeforeCreate = "beforeInsert",
+	BeforeUpdate = "beforeUpdate",
+	BeforeDelete = "beforeDelete",
+	BeforeRead = "beforeRead"
+}
+export type Hook<T extends WabeTypes> = {
+	operationType: OperationType;
+	className?: T;
+	priority: number;
+	callback: (hookObject: HookObject<T>) => Promise<void> | void;
+};
+export type TypedNewData<T extends keyof WabeTypes["types"]> = Record<keyof WabeTypes["types"][T], any>;
+export declare const _findHooksByPriority: <T extends unknown>({ className, operationType, priority, config, }: {
+	operationType: OperationType;
+	className: T;
+	priority: number;
+	config: WabeConfig<any>;
+}) => Promise<Hook<any>[]>;
+export declare const initializeHook: <T extends unknown>({ className, newData, context, }: {
+	className: T;
+	newData?: TypedNewData<any> | undefined;
+	context: WabeContext<any>;
+}) => {
+	runOnSingleObject: ({ operationType, id, object: inputObject, }: {
+		operationType: OperationType;
+		id?: string | undefined;
+		object?: OutputType<any, any> | undefined;
+	}) => Promise<{
+		object: undefined;
+		newData: {};
+	} | {
+		object: OutputType<any, any>;
+		newData: MutationData<any>;
+	}>;
+	runOnMultipleObjects: ({ operationType, where, objects: inputObjects, }: {
+		operationType: OperationType;
+		where?: WhereType<any, any> | undefined;
+		objects?: OutputType<any, any>[] | undefined;
+	}) => Promise<{
+		objects: OutputType<any, any>[];
+		newData: MutationData<any>[];
+	}>;
+};
+export declare const getDefaultHooks: () => Hook<any>[];
+export type DevWabeTypes = {
+	types: WabeSchemaTypes;
+	scalars: WabeSchemaScalars;
+	enums: WabeSchemaEnums;
+};
+export declare const generateCodegen: ({ schema, path, graphqlSchema, }: {
+	schema: SchemaInterface<any>;
+	path: string;
+	graphqlSchema: GraphQLSchema;
+}) => Promise<void>;
+/**
+ * A file adpater that upload a file and returns the url of the file
+ * @param file: File
+ * @returns The url of the uploaded file
+ */
+export type WabeFileAdapter = (file: File) => Promise<string>;
+/**
+ * The file config contains the adapter to use to upload file
+ */
+export interface FileConfig {
+	adapter: WabeFileAdapter;
+}
+export interface WabeConfig<T extends WabeTypes> {
+	port: number;
+	schema?: SchemaInterface<T>;
+	database: DatabaseConfig;
+	codegen?: {
+		enabled: true;
+		path: string;
+	} | {
+		enabled?: false;
+	};
+	authentication?: AuthenticationConfig<T>;
+	routes?: WabeRoute[];
+	rootKey: string;
+	hooks?: Hook<any>[];
+	file?: FileConfig;
+}
+export type WabeTypes = {
+	types: Record<any, any>;
+	scalars: string;
+	enums: string;
+};
+export type WobeCustomContext<T extends WabeTypes> = {
+	wabe: WabeContext<T>;
+};
+export declare class Wabe<T extends WabeTypes> {
+	server: Wobe<WobeCustomContext<T>>;
+	config: WabeConfig<T>;
+	controllers: {
+		database: DatabaseController<T>;
+	};
+	constructor({ port, schema, database, authentication, rootKey, codegen, hooks, file, }: WabeConfig<T>);
+	loadAuthenticationMethods(): void;
+	loadHooks(): void;
+	loadDefaultRoutes(): void;
+	start(): Promise<void>;
+	close(): Promise<void>;
+}
+export declare const signInWithResolver: (_: any, { input, }: {
+	input: SignInWithInput;
+}, context: WabeContext<DevWabeTypes>) => Promise<{
+	accessToken: null;
+	refreshToken: null;
+	id: string;
+} | {
+	accessToken: string;
+	refreshToken: string;
+	id: string;
+}>;
+export declare const signUpWithResolver: (_: any, { input, }: {
+	input: SignUpWithInput;
+}, context: WabeContext<any>) => Promise<{
+	accessToken: string;
+	refreshToken: string;
+	id: any;
+}>;
+export interface TokenResponseBody {
+	access_token: string;
+	token_type?: string;
+	expires_in?: number;
+	refresh_token?: string;
+	scope?: string;
+}
+export declare class OAuth2Client {
+	clientId: string;
+	private authorizeEndpoint;
+	private tokenEndpoint;
+	private redirectURI;
+	constructor(clientId: string, authorizeEndpoint: string, tokenEndpoint: string, redirectURI: string);
+	createAuthorizationURL(options?: {
+		state?: string;
+		codeVerifier?: string;
+		scopes?: string[];
+	}): Promise<URL>;
+	validateAuthorizationCode<_TokenResponseBody extends TokenResponseBody>(authorizationCode: string, options?: {
+		codeVerifier?: string;
+		credentials?: string;
+		authenticateWith?: "http_basic_auth" | "request_body";
+	}): Promise<_TokenResponseBody>;
+	refreshAccessToken<_TokenResponseBody extends TokenResponseBody>(refreshToken: string, options?: {
+		credentials?: string;
+		authenticateWith?: "http_basic_auth" | "request_body";
+		scopes?: string[];
+	}): Promise<_TokenResponseBody>;
+	_sendTokenRequest<_TokenResponseBody extends TokenResponseBody>(body: URLSearchParams, options?: {
+		credentials?: string;
+		authenticateWith?: "http_basic_auth" | "request_body";
+	}): Promise<_TokenResponseBody>;
+}
+export interface Tokens {
+	accessToken: string;
+	refreshToken?: string | null;
+	accessTokenExpiresAt?: Date;
+	refreshTokenExpiresAt?: Date | null;
+	idToken?: string;
+}
+export interface OAuth2ProviderWithPKCE {
+	createAuthorizationURL(state: string, codeVerifier: string): Promise<URL>;
+	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
+	refreshAccessToken?(refreshToken: string): Promise<Tokens>;
+}
+export declare class Google implements OAuth2ProviderWithPKCE {
+	private client;
+	private clientSecret;
+	constructor(config: WabeConfig<any>);
+	createAuthorizationURL(state: string, codeVerifier: string, options?: {
+		scopes?: string[];
+	}): Promise<URL>;
+	validateAuthorizationCode(code: string, codeVerifier: string): Promise<Tokens>;
+	refreshAccessToken(refreshToken: string): Promise<Tokens>;
+	getUserInfo(accessToken: string, idToken: string): Promise<{
+		email: any;
+		verifiedEmail: any;
+	}>;
+}
+
+export {
+	AuthenticationProvider$1 as AuthenticationProvider,
+};
+
+export {};