@m1212e/rumble 0.11.7 → 0.12.3

package/index.d.ts

@@ -1,833 +0,0 @@
-import { GraphQLSchema, GraphQLFieldResolver, GraphQLError } from 'graphql';
-import { Client } from '@urql/core';
-import * as SchemaBuilder from '@pothos/core';
-import SchemaBuilder__default, { SchemaTypes, BasePlugin, PothosOutputFieldConfig } from '@pothos/core';
-import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-import { PgDatabase, PgEnum } from 'drizzle-orm/pg-core';
-import * as _pothos_plugin_drizzle from '@pothos/plugin-drizzle';
-import { DrizzleClient } from '@pothos/plugin-drizzle';
-import * as fets from 'fets';
-import * as graphql_yoga from 'graphql-yoga';
-import { createPubSub, YogaServerOptions } from 'graphql-yoga';
-import * as drizzle_orm from 'drizzle-orm';
-import { useSofa } from 'sofa-api';
-import { MySqlDatabase } from 'drizzle-orm/mysql-core';
-import { SingleStoreDatabase } from 'drizzle-orm/singlestore-core';
-import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-
-declare function generateFromSchema({ outputPath, schema, rumbleImportPath, apiUrl, useExternalUrqlClient, }: {
-    schema: GraphQLSchema;
-    outputPath: string;
-    rumbleImportPath?: string;
-    apiUrl?: string;
-    useExternalUrqlClient?: boolean | string;
-}): Promise<void>;
-
-declare const argsKey = "__args";
-
-type UnArray<T> = T extends Array<infer U> ? U : T;
-type RequireAtLeastOneFieldSet<T> = {
-    [K in keyof T]: Required<Pick<T, K>> & Partial<Omit<T, K>>;
-}[keyof T];
-
-/**
- * A gql object defined from the generated types.
- * Most keys are functions that take a selection set and return a promise of the selected data.
- */
-type QueryableObjectFromGeneratedTypes<Q> = {
-    [Key in keyof Q]: QueryableObjectField$1<Q[Key]>;
-};
-type QueryableObjectField$1<T> = T extends (p: infer QueryArgs) => infer QueryResponse ? <Selected extends QueryArgs extends Record<string, any> ? // in that case we want to extend the object with an args key property
-ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>> & {
-    [argsKey]: QueryArgs;
-} : ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>>>(s: Selected) => QueryResponse extends null ? Response<QueryResponse extends Array<any> ? ApplySelection<NonNullable<UnArray<QueryResponse>>, Selected>[] : ApplySelection<NonNullable<UnArray<QueryResponse>>, Selected>> | null : Response<QueryResponse extends Array<any> ? ApplySelection<UnArray<QueryResponse>, Selected>[] : ApplySelection<UnArray<QueryResponse>, Selected>> : Response<T>;
-/**
- * The input to select fields for an object
- */
-type ObjectFieldSelection<O> = RequireAtLeastOneFieldSet<{
-    [Key in keyof O]: NonNullable<UnArray<O[Key]>> extends (p: infer P) => infer A ? P extends Record<string, any> ? ObjectFieldSelection<UnArray<NonNullable<A>>> & {
-        [argsKey]: P;
-    } : ObjectFieldSelection<UnArray<NonNullable<A>>> : boolean;
-}>;
-type ApplySelection<Object, Selection> = {
-    [Key in keyof Selection & keyof Object]: Object[Key] extends (p: infer _P) => infer _A ? ReturnType<Object[Key]> extends Array<any> ? Array<ApplySelection<UnArray<ReturnType<Object[Key]>>, Selection[Key]>> : ApplySelection<UnArray<Object[Key]>, Selection[Key]> : Object[Key];
-};
-type Subscribeable<Data> = {
-    subscribe: (subscription: (value: Data) => void) => () => void;
-};
-type Response<Data> = {
-    then: (onFulfilled: (value: Subscribeable<Data> & Data) => void) => void;
-} & Subscribeable<Data | undefined>;
-
-declare function makeLiveQuery<Query extends Record<string, any>>({ urqlClient, availableSubscriptions, }: {
-    urqlClient: Client;
-    availableSubscriptions: Set<string>;
-}): QueryableObjectFromGeneratedTypes<Query>;
-
-declare function makeMutation<Mutation extends Record<string, any>>({ urqlClient, }: {
-    urqlClient: Client;
-}): QueryableObjectFromGeneratedTypes<Mutation>;
-
-declare function makeQuery<Query extends Record<string, any>>({ urqlClient, }: {
-    urqlClient: Client;
-}): QueryableObjectFromGeneratedTypes<Query>;
-
-declare function makeSubscription<Subscription extends Record<string, any>>({ urqlClient, }: {
-    urqlClient: Client;
-}): SubscriptionObject<Subscription>;
-type SubscriptionObject<Q> = {
-    [Key in keyof Q]: QueryableObjectField<Q[Key]>;
-};
-type QueryableObjectField<T> = T extends (p: infer QueryArgs) => infer QueryResponse ? <Selected extends QueryArgs extends Record<string, any> ? ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>> & {
-    [argsKey]: QueryArgs;
-} : ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>>>(s: Selected) => QueryResponse extends null ? Subscribeable<NonNullable<QueryResponse> extends Array<any> ? ApplySelection<UnArray<NonNullable<QueryResponse>>, Selected>[] : ApplySelection<UnArray<NonNullable<QueryResponse>>, Selected>> | null : Subscribeable<QueryResponse extends Array<any> ? ApplySelection<UnArray<QueryResponse>, Selected>[] : ApplySelection<UnArray<QueryResponse>, Selected>> : Subscribeable<T>;
-
-declare const pluginName = "ManualFiltersPlugin";
-
-declare const applyFiltersKey = "applyFilters";
-declare class ManualFiltersPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
-    wrapResolve(resolver: GraphQLFieldResolver<unknown, Types["Context"], object>, fieldConfig: PothosOutputFieldConfig<Types>): GraphQLFieldResolver<unknown, Types["Context"], object>;
-}
-
-type Filter<Context, T> = (p: {
-    context: Context;
-    entities: T[];
-}) => T[] | Promise<T[]>;
-type ApplyFiltersField<Context, T> = Filter<Context, T> | Filter<Context, T>[] | undefined;
-declare global {
-    export namespace PothosSchemaTypes {
-        interface Plugins<Types extends SchemaTypes> {
-            [pluginName]: ManualFiltersPlugin<Types>;
-        }
-        interface ObjectTypeOptions<Types extends SchemaTypes, Shape> {
-            [applyFiltersKey]?: ApplyFiltersField<Types["Context"], any>;
-        }
-    }
-}
-
-/**
- *
- * Helper function to map a drizzle findFirst query result,
- * which may be optional, to a correct drizzle type.
- *
- * @throws RumbleError
- *
- * @example
- *
- * ```ts
- * schemaBuilder.queryFields((t) => {
-   return {
-     findFirstUser: t.drizzleField({
-       type: UserRef,
-       resolve: (query, root, args, ctx, info) => {
-         return (
-           db.query.users
-             .findFirst({
-               ...query,
-               where: ctx.abilities.users.filter("read").single.where,
-             })
-             // note that we need to manually raise an error if the value is not found
-             .then(assertFindFirstExists)
-         );
-       },
-     }),
-   };
- });
- * ```
- */
-declare const assertFindFirstExists: <T>(value: T | undefined) => T;
-/**
- *
- * Helper function to map a drizzle findFirst query result,
- * which may be optional, to a correct drizzle type.
- *
- * @throws RumbleError
- *
- * @example
- *
- * ```ts
-  schemaBuilder.mutationFields((t) => {
-    return {
-      updateUsername: t.drizzleField({
-        type: UserRef,
-        args: {
-          userId: t.arg.int({ required: true }),
-          newName: t.arg.string({ required: true }),
-        },
-        resolve: (query, root, args, ctx, info) => {
-          return db
-            .update(schema.users)
-            .set({
-              name: args.newName,
-            })
-            .where(
-              and(
-                eq(schema.users.id, args.userId),
-                ctx.abilities.users.filter("update").single.where
-              )
-            )
-            .returning({ id: schema.users.id, name: schema.users.name })
-        // note that we need to manually raise an error if the value is not found
-            .then(assertFirstEntryExists);
-        },
-      }),
-    };
-  });
- * ```
- */
-declare const assertFirstEntryExists: <T>(value: T[]) => T;
-/**
- * Helper to map null fields to undefined
- * @param obj The object to map
- * @returns The mapped object with all fields of 'null' transformed to 'undefined'
- *
- * This becomes useful for update mutations where you do not want to pass null (unset value in db)
- * but undefined (do not touch value in db) in case of a value not beeing set in the args of said mutation
- * @example
- * ```ts
- *  updateUser: t.drizzleField({
-      type: User,
-      args: {
-        id: t.arg.string({ required: true }),
-        email: t.arg.string(),
-        lastName: t.arg.string(),
-        firstName: t.arg.string(),
-      },
-      resolve: async (query, root, args, ctx, info) => {
-        const mappedArgs = mapNullFieldsToUndefined(args);
-        const user = await db.transaction(async (tx) => {
-          const user = await tx
-            .update(schema.user)
-            .set({
-
-              // email: args.email ?? undefined,
-              // lastName: args.lastName ?? undefined,
-              // firstName: args.firstName ?? undefined,
-
-              // becomes this
-
-              email: mappedArgs.email,
-              lastName: mappedArgs.lastName,
-              firstName: mappedArgs.firstName,
-            })
-            .returning()
-            .then(assertFirstEntryExists);
-          return user;
-        });
-
-        pubsub.updated(user.id);
-
-        return db.query.user
-          .findFirst(
-            query(
-              ctx.abilities.user.filter('read', {
-                inject: {
-                  where: { id: user.id },
-                },
-              }).query.single,
-            ),
-          )
-          .then(assertFindFirstExists);
-      },
-    }),
- *
- *
- * ```
- */
-declare function mapNullFieldsToUndefined<T extends object>(obj: T): { [K in keyof T]: T[K] extends null ? undefined : Exclude<T[K], null>; };
-
-type GenericDrizzleDbTypeConstraints = {
-    query: {
-        [key: string]: {
-            findMany: (P: Partial<{
-                where: any;
-                columns: any;
-                limit: any;
-            }>) => any;
-            findFirst: (P: Partial<{
-                where: any;
-                columns: any;
-            }>) => any;
-        };
-    };
-    execute?: PgDatabase<any, any>["execute"] | MySqlDatabase<any, any>["execute"] | SingleStoreDatabase<any, any>["execute"] | undefined;
-    run?: BaseSQLiteDatabase<any, any>["run"];
-} & DrizzleClient;
-
-type CustomRumblePothosConfig = Omit<ConstructorParameters<typeof SchemaBuilder__default>[0], "smartSubscriptions" | "drizzle">;
-type RumbleInput<UserContext extends Record<string, any>, DB extends GenericDrizzleDbTypeConstraints, RequestEvent extends Record<string, any>, Action extends string, PothosConfig extends CustomRumblePothosConfig> = {
-    /**
-     * Your drizzle database instance
-     */
-    db: DB;
-    /**
-     * A function for providing context for each request based on the incoming HTTP Request.
-     * The type of the parameter equals the HTTPRequest type of your chosen server.
-     */
-    context?: ((event: RequestEvent) => Promise<UserContext> | UserContext) | undefined;
-    /**
-     * If you only want to disable query, mutation or subscription default objects, you can do so here
-     */
-    disableDefaultObjects?: {
-        mutation?: boolean;
-        subscription?: boolean;
-        query?: boolean;
-    };
-    /**
-     * The actions that are available
-     */
-    actions?: Action[];
-    /**
-     * Customization for subscriptions. See https://the-guild.dev/graphql/yoga-server/docs/features/subscriptions#distributed-pubsub-for-production
-     */
-    subscriptions?: Parameters<typeof createPubSub>;
-    /**
-     * Options passed along to the pothos schema builder.
-     */
-    pothosConfig?: PothosConfig;
-    /**
-     * Limits the returned amount when querying lists. Set to null to disable.
-     * @default 100
-     */
-    defaultLimit?: number | undefined | null;
-    /**
-     * rumble supports fuzzy search for the query helpers. This enables the users of your API to search for entities via fuzzy search inputs.
-     * This currently only is supported by postgres databases and will fail if enabled on other dialects.
-     *
-     * Please note that this will install the pg_trgm extension on startup if your database does not have it already installed.
-     * https://www.postgresql.org/docs/current/pgtrgm.html
-     */
-    search?: {
-        /**
-         * Whether search is enabled
-         */
-        enabled?: boolean;
-        /**
-         * The threshold for cutting off non matching results. Defaults to 0.1. Lower = more results.
-         */
-        threshold?: number;
-    } | undefined;
-};
-
-type NumberWhereInputArgument = {
-    eq?: number;
-    ne?: number;
-    gt?: number;
-    gte?: number;
-    lt?: number;
-    lte?: number;
-    in?: number[];
-    notIn?: number[];
-    like?: string;
-    ilike?: string;
-    notLike?: string;
-    notIlike?: string;
-    isNull?: boolean;
-    isNotNull?: boolean;
-    arrayOverlaps?: number[];
-    arrayContained?: number[];
-    arrayContains?: number[];
-    AND?: NumberWhereInputArgument[];
-    OR?: NumberWhereInputArgument[];
-    NOT?: NumberWhereInputArgument;
-};
-type StringWhereInputArgument = {
-    eq?: string;
-    ne?: string;
-    gt?: string;
-    gte?: string;
-    lt?: string;
-    lte?: string;
-    in?: string[];
-    notIn?: string[];
-    like?: string;
-    ilike?: string;
-    notLike?: string;
-    notIlike?: string;
-    isNull?: boolean;
-    isNotNull?: boolean;
-    arrayOverlaps?: string[];
-    arrayContained?: string[];
-    arrayContains?: string[];
-    AND?: StringWhereInputArgument[];
-    OR?: StringWhereInputArgument[];
-    NOT?: StringWhereInputArgument;
-};
-type DateWhereInputArgument = {
-    eq?: Date;
-    ne?: Date;
-    gt?: Date;
-    gte?: Date;
-    lt?: Date;
-    lte?: Date;
-    in?: Date[];
-    notIn?: Date[];
-    like?: string;
-    ilike?: string;
-    notLike?: string;
-    notIlike?: string;
-    isNull?: boolean;
-    isNotNull?: boolean;
-    arrayOverlaps?: Date[];
-    arrayContained?: Date[];
-    arrayContains?: Date[];
-    AND?: DateWhereInputArgument[];
-    OR?: DateWhereInputArgument[];
-    NOT?: DateWhereInputArgument;
-};
-
-type EnumTypes = PgEnum<any>;
-type NonEnumFields<T> = {
-    [K in keyof T as T[K] extends EnumTypes ? never : K]: T[K];
-};
-
-declare const rumble: <UserContext extends Record<string, any>, DB extends GenericDrizzleDbTypeConstraints, RequestEvent extends Record<string, any>, PothosConfig extends CustomRumblePothosConfig, Action extends string = "read" | "update" | "delete">(rumbleInput: RumbleInput<UserContext, DB, RequestEvent, Action, PothosConfig>) => {
-    /**
-   * The ability builder. Use it to declare whats allowed for each entity in your DB.
-   *
-   * @example
-   *
-   * ```ts
-   * // users can edit themselves
-   abilityBuilder.users
-     .allow(["read", "update", "delete"])
-     .when(({ userId }) => ({ where: eq(schema.users.id, userId) }));
-   
-   // everyone can read posts
-   abilityBuilder.posts.allow("read");
-   *
-   * ```
-   */
-    abilityBuilder: (keyof DB["query"] extends infer T extends keyof DB["query"] ? { [key in T]: {
-        allow: (action: Action | Action[]) => {
-            when: (queryFilter: Parameters<DB["query"][key]["findMany"]>[0] | ((context: UserContext) => "allow" | Parameters<DB["query"][key]["findMany"]>[0] | undefined)) => void;
-        };
-        filter: (action: Action | Action[]) => {
-            by: (explicitFilter: Filter<UserContext, NonNullable<Awaited<ReturnType<DB["query"][key]["findFirst"]>>>>) => void;
-        };
-    }; } : never) & {
-        z_registeredQueryFilters: keyof DB["query"] extends infer T_1 extends keyof DB["query"] ? { [key_1 in T_1]: { [key_2 in Action]: any[] | "unspecified"; }; } : never;
-        z_registeredFilters: keyof DB["query"] extends infer T_2 extends keyof DB["query"] ? { [key_3 in T_2]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never;
-        z_buildWithUserContext: (userContext: UserContext) => keyof DB["query"] extends infer T_3 extends keyof DB["query"] ? { [key_5 in T_3]: {
-            filter: <Injection extends Parameters<DB["query"][key_5]["findMany"]>[0]>(action: Action, options?: {
-                inject?: Injection | undefined;
-            } | undefined) => {
-                query: {
-                    single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findFirst"]>[0]>>, "columns" | "where">;
-                    many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findMany"]>[0]>>, "columns" | "where" | "limit">;
-                };
-                sql: {
-                    readonly where: drizzle_orm.SQL<unknown> | undefined;
-                };
-            };
-            runtimeFilters: (action: Action) => (keyof DB["query"] extends infer T_4 extends keyof DB["query"] ? { [key_3 in T_4]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never)[key_5][Action];
-        }; } : never;
-    };
-    /**
-     * The pothos schema builder. See https://pothos-graphql.dev/docs/plugins/drizzle
-     */
-    schemaBuilder: PothosSchemaTypes.SchemaBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
-        Context: Awaited<UserContext & {
-            abilities: keyof DB["query"] extends infer T_3 extends keyof DB["query"] ? { [key_5 in T_3]: {
-                filter: <Injection extends Parameters<DB["query"][key_5]["findMany"]>[0]>(action: Action, options?: {
-                    inject?: Injection | undefined;
-                } | undefined) => {
-                    query: {
-                        single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findFirst"]>[0]>>, "columns" | "where">;
-                        many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findMany"]>[0]>>, "columns" | "where" | "limit">;
-                    };
-                    sql: {
-                        readonly where: drizzle_orm.SQL<unknown> | undefined;
-                    };
-                };
-                runtimeFilters: (action: Action) => (keyof DB["query"] extends infer T_4 extends keyof DB["query"] ? { [key_3 in T_4]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never)[key_5][Action];
-            }; } : never;
-        }>;
-        DrizzleRelations: DB["_"]["relations"];
-        Scalars: {
-            JSON: {
-                Input: unknown;
-                Output: unknown;
-            };
-            Date: {
-                Input: Date;
-                Output: Date;
-            };
-            DateTime: {
-                Input: Date;
-                Output: Date;
-            };
-        };
-        Inputs: {
-            IntWhereInputArgument: NumberWhereInputArgument;
-            FloatWhereInputArgument: NumberWhereInputArgument;
-            StringWhereInputArgument: StringWhereInputArgument;
-            DateWhereInputArgument: DateWhereInputArgument;
-        };
-    }>>;
-    /**
-   * Creates the native yoga instance. Can be used to run an actual HTTP server.
-   *
-   * @example
-   *
-   * ```ts
-   *
-    import { createServer } from "node:http";
-    * const server = createServer(createYoga());
-    server.listen(3000, () => {
-        console.info("Visit http://localhost:3000/graphql");
-        });
-        * ```
-   * https://the-guild.dev/graphql/yoga-server/docs#server
-   */
-    createYoga: (args?: (Omit<YogaServerOptions<RequestEvent, any>, "schema" | "context"> & {
-        /**
-         * Determines if the API should disclose various things about its structure.
-         * Defaults to `process.env.NODE_ENV === "development"`.
-         * If enabled, the api will allow introspection requests, provide the graphiql
-         * explorer and will not apply the additional envelop armor plugin.
-         */
-        enableApiDocs?: boolean;
-    }) | undefined) => graphql_yoga.YogaServerInstance<RequestEvent, {}>;
-    /**
-     * Creates a sofa instance to offer a REST API.
-    ```ts
-    import express from 'express';
-    
-    const app = express();
-    const sofa = createSofa(...);
-    
-    app.use('/api', useSofa({ schema }));
-    ```
-    * https://the-guild.dev/graphql/sofa-api/docs#usage
-     */
-    createSofa: (args: Omit<Parameters<typeof useSofa>[0], "schema" | "context">) => fets.Router<any, {}, {
-        [TKey: string]: never;
-    }>;
-    /**
-     * A function for creating default objects for your schema
-     */
-    object: <ExplicitTableName extends keyof NonEnumFields<NonNullable<DB["_"]["relations"]["schema"]>>, RefName extends string>({ table, refName, readAction, adjust, }: {
-        table: ExplicitTableName;
-        refName?: RefName | undefined;
-        readAction?: Action | undefined;
-        adjust?: ((t: _pothos_plugin_drizzle.DrizzleObjectFieldBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
-            Context: Awaited<UserContext & {
-                abilities: keyof DB["query"] extends infer T_4 extends keyof DB["query"] ? { [key_5 in T_4]: {
-                    filter: <Injection extends Parameters<DB["query"][key_5]["findMany"]>[0]>(action: Action, options?: {
-                        inject?: Injection | undefined;
-                    } | undefined) => {
-                        query: {
-                            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findFirst"]>[0]>>, "columns" | "where">;
-                            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findMany"]>[0]>>, "columns" | "where" | "limit">;
-                        };
-                        sql: {
-                            readonly where: drizzle_orm.SQL<unknown> | undefined;
-                        };
-                    };
-                    runtimeFilters: (action: Action) => (keyof DB["query"] extends infer T_5 extends keyof DB["query"] ? { [key_3 in T_5]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never)[key_5][Action];
-                }; } : never;
-            }>;
-            DrizzleRelations: DB["_"]["relations"];
-            Scalars: {
-                JSON: {
-                    Input: unknown;
-                    Output: unknown;
-                };
-                Date: {
-                    Input: Date;
-                    Output: Date;
-                };
-                DateTime: {
-                    Input: Date;
-                    Output: Date;
-                };
-            };
-            Inputs: {
-                IntWhereInputArgument: NumberWhereInputArgument;
-                FloatWhereInputArgument: NumberWhereInputArgument;
-                StringWhereInputArgument: StringWhereInputArgument;
-                DateWhereInputArgument: DateWhereInputArgument;
-            };
-        }>, drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName], NonNullable<Awaited<ReturnType<DB["query"][ExplicitTableName]["findFirst"]>>>, { [Key in keyof Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"] & string as Key]: Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"][Key]["_"]["notNull"] extends true ? Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"][Key]["_"]["data"] : Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"][Key]["_"]["data"] | null; } extends infer T_5 ? { [K in keyof T_5]: { [Key in keyof Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"] & string as Key]: Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"][Key]["_"]["notNull"] extends true ? Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"][Key]["_"]["data"] : Extract<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]["table"], {
-            _: {
-                brand: "Table";
-            };
-        }>["_"]["columns"][Key]["_"]["data"] | null; }[K]; } : never>) => SchemaBuilder.FieldMap) | undefined;
-    }) => _pothos_plugin_drizzle.DrizzleObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
-        Context: Awaited<UserContext & {
-            abilities: keyof DB["query"] extends infer T_4 extends keyof DB["query"] ? { [key_5 in T_4]: {
-                filter: <Injection extends Parameters<DB["query"][key_5]["findMany"]>[0]>(action: Action, options?: {
-                    inject?: Injection | undefined;
-                } | undefined) => {
-                    query: {
-                        single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findFirst"]>[0]>>, "columns" | "where">;
-                        many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findMany"]>[0]>>, "columns" | "where" | "limit">;
-                    };
-                    sql: {
-                        readonly where: drizzle_orm.SQL<unknown> | undefined;
-                    };
-                };
-                runtimeFilters: (action: Action) => (keyof DB["query"] extends infer T_5 extends keyof DB["query"] ? { [key_3 in T_5]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never)[key_5][Action];
-            }; } : never;
-        }>;
-        DrizzleRelations: DB["_"]["relations"];
-        Scalars: {
-            JSON: {
-                Input: unknown;
-                Output: unknown;
-            };
-            Date: {
-                Input: Date;
-                Output: Date;
-            };
-            DateTime: {
-                Input: Date;
-                Output: Date;
-            };
-        };
-        Inputs: {
-            IntWhereInputArgument: NumberWhereInputArgument;
-            FloatWhereInputArgument: NumberWhereInputArgument;
-            StringWhereInputArgument: StringWhereInputArgument;
-            DateWhereInputArgument: DateWhereInputArgument;
-        };
-    }>, ExplicitTableName, drizzle_orm.BuildQueryResult<drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>, drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName], true | drizzle_orm.DBQueryConfig<"one", drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>, drizzle_orm.ExtractTablesWithRelations<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})["tables"]>[ExplicitTableName]>>>;
-    /**
-     * A function for creating where args to filter entities
-     */
-    whereArg: <ExplicitTableName extends keyof NonEnumFields<NonNullable<DB["_"]["relations"]["schema"]>>, RefName_1 extends string>({ table, refName, dbName, }: Partial<{
-        table: ExplicitTableName;
-        refName: RefName_1 | undefined;
-        dbName: string;
-    }> & ({
-        dbName: string;
-    } | {
-        table: ExplicitTableName;
-    })) => PothosSchemaTypes.InputObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
-        Context: Awaited<UserContext & {
-            abilities: keyof DB["query"] extends infer T_4 extends keyof DB["query"] ? { [key_5 in T_4]: {
-                filter: <Injection extends Parameters<DB["query"][key_5]["findMany"]>[0]>(action: Action, options?: {
-                    inject?: Injection | undefined;
-                } | undefined) => {
-                    query: {
-                        single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findFirst"]>[0]>>, "columns" | "where">;
-                        many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findMany"]>[0]>>, "columns" | "where" | "limit">;
-                    };
-                    sql: {
-                        readonly where: drizzle_orm.SQL<unknown> | undefined;
-                    };
-                };
-                runtimeFilters: (action: Action) => (keyof DB["query"] extends infer T_5 extends keyof DB["query"] ? { [key_3 in T_5]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never)[key_5][Action];
-            }; } : never;
-        }>;
-        DrizzleRelations: DB["_"]["relations"];
-        Scalars: {
-            JSON: {
-                Input: unknown;
-                Output: unknown;
-            };
-            Date: {
-                Input: Date;
-                Output: Date;
-            };
-            DateTime: {
-                Input: Date;
-                Output: Date;
-            };
-        };
-        Inputs: {
-            IntWhereInputArgument: NumberWhereInputArgument;
-            FloatWhereInputArgument: NumberWhereInputArgument;
-            StringWhereInputArgument: StringWhereInputArgument;
-            DateWhereInputArgument: DateWhereInputArgument;
-        };
-    }>, {
-        [x: string]: unknown;
-    }>;
-    /**
-     * A function for creating order args to sort entities
-     */
-    orderArg: <ExplicitTableName extends keyof NonEnumFields<NonNullable<DB["_"]["relations"]["schema"]>>, RefName_2 extends string>({ table, refName, dbName, }: Partial<{
-        table: ExplicitTableName;
-        refName: RefName_2 | undefined;
-        dbName: string;
-    }> & ({
-        dbName: string;
-    } | {
-        table: ExplicitTableName;
-    })) => PothosSchemaTypes.InputObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
-        Context: Awaited<UserContext & {
-            abilities: keyof DB["query"] extends infer T_4 extends keyof DB["query"] ? { [key_5 in T_4]: {
-                filter: <Injection extends Parameters<DB["query"][key_5]["findMany"]>[0]>(action: Action, options?: {
-                    inject?: Injection | undefined;
-                } | undefined) => {
-                    query: {
-                        single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findFirst"]>[0]>>, "columns" | "where">;
-                        many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findMany"]>[0]>>, "columns" | "where" | "limit">;
-                    };
-                    sql: {
-                        readonly where: drizzle_orm.SQL<unknown> | undefined;
-                    };
-                };
-                runtimeFilters: (action: Action) => (keyof DB["query"] extends infer T_5 extends keyof DB["query"] ? { [key_3 in T_5]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never)[key_5][Action];
-            }; } : never;
-        }>;
-        DrizzleRelations: DB["_"]["relations"];
-        Scalars: {
-            JSON: {
-                Input: unknown;
-                Output: unknown;
-            };
-            Date: {
-                Input: Date;
-                Output: Date;
-            };
-            DateTime: {
-                Input: Date;
-                Output: Date;
-            };
-        };
-        Inputs: {
-            IntWhereInputArgument: NumberWhereInputArgument;
-            FloatWhereInputArgument: NumberWhereInputArgument;
-            StringWhereInputArgument: StringWhereInputArgument;
-            DateWhereInputArgument: DateWhereInputArgument;
-        };
-    }>, {
-        [x: string]: unknown;
-    }>;
-    /**
-     * A function for creating default READ queries.
-     * Make sure the objects for the table you are creating the queries for are implemented
-     */
-    query: <ExplicitTableName extends keyof NonEnumFields<NonNullable<DB["_"]["relations"]["schema"]>>>({ table, readAction, listAction, }: {
-        table: ExplicitTableName;
-        readAction?: Action | undefined;
-        listAction?: Action | undefined;
-    }) => void;
-    /**
-     * A function for creating a pubsub instance for a table. Use this to publish or subscribe events
-     */
-    pubsub: <ExplicitTableName extends keyof NonEnumFields<NonNullable<DB["_"]["relations"]["schema"]>>>({ table, }: {
-        table: ExplicitTableName;
-    }) => {
-        registerOnInstance({ instance, action, primaryKeyValue, }: {
-            instance: {
-                register: (id: string) => void;
-            };
-            action: "created" | "removed" | "updated";
-            primaryKeyValue?: string;
-        }): void;
-        created(): void;
-        removed(): void;
-        updated(primaryKeyValue?: any | any[]): void;
-    };
-    /**
-     * A function to implement enums for graphql usage.
-     * The other helpers use this helper internally so in most cases you do not have to
-     * call this helper directly, unless you need the reference to an enum type
-     */
-    enum_: <ExplicitEnumVariableName extends keyof (NonNullable<DB["_"]["relations"]["schema"]> extends infer T_4 ? { [K in keyof T_4 as NonNullable<DB["_"]["relations"]["schema"]>[K] extends drizzle_orm_pg_core.PgEnum<any> ? K : never]: NonNullable<DB["_"]["relations"]["schema"]>[K]; } : never), EnumColumn extends drizzle_orm_pg_core.PgEnum<any>, RefName_3 extends string>({ tsName, enumColumn, refName, }: Partial<{
-        tsName: ExplicitEnumVariableName;
-        enumColumn: EnumColumn;
-        refName?: RefName_3 | undefined;
-    }> & ({
-        tsName: ExplicitEnumVariableName;
-    } | {
-        enumColumn: EnumColumn;
-    })) => PothosSchemaTypes.EnumRef<PothosSchemaTypes.ExtendDefaultTypes<{
-        Context: Awaited<UserContext & {
-            abilities: keyof DB["query"] extends infer T_5 extends keyof DB["query"] ? { [key_5 in T_5]: {
-                filter: <Injection extends Parameters<DB["query"][key_5]["findMany"]>[0]>(action: Action, options?: {
-                    inject?: Injection | undefined;
-                } | undefined) => {
-                    query: {
-                        single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findFirst"]>[0]>>, "columns" | "where">;
-                        many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_5]["findMany"]>[0]>>, "columns" | "where" | "limit">;
-                    };
-                    sql: {
-                        readonly where: drizzle_orm.SQL<unknown> | undefined;
-                    };
-                };
-                runtimeFilters: (action: Action) => (keyof DB["query"] extends infer T_6 extends keyof DB["query"] ? { [key_3 in T_6]: { [key_4 in Action]: Filter<UserContext, any>[]; }; } : never)[key_5][Action];
-            }; } : never;
-        }>;
-        DrizzleRelations: DB["_"]["relations"];
-        Scalars: {
-            JSON: {
-                Input: unknown;
-                Output: unknown;
-            };
-            Date: {
-                Input: Date;
-                Output: Date;
-            };
-            DateTime: {
-                Input: Date;
-                Output: Date;
-            };
-        };
-        Inputs: {
-            IntWhereInputArgument: NumberWhereInputArgument;
-            FloatWhereInputArgument: NumberWhereInputArgument;
-            StringWhereInputArgument: StringWhereInputArgument;
-            DateWhereInputArgument: DateWhereInputArgument;
-        };
-    }>, any, any>;
-    /**
-     * Create a client to consume a rumble graphql api at the specified location.
-     * Requires GraphQL, does not work with the SOFA REST API.
-     */
-    clientCreator: ({ apiUrl, outputPath, rumbleImportPath, useExternalUrqlClient, }: {
-        outputPath: string;
-        apiUrl?: string;
-        rumbleImportPath?: string;
-        useExternalUrqlClient?: string;
-    }) => Promise<void>;
-};
-
-/**
- * An error that gets raised by rumble whenever something does not go according to plan.
- * Mostly internals, configuration errors or other unexpected things.
- */
-declare class RumbleError extends Error {
-    constructor(message: string);
-}
-/**
- * An error that gets raised by rumble whenever an error occurs in a resolver, containing
- * information safely exposeable to the user.
- * E.g. the assert helpers issue these.
- */
-declare class RumbleErrorSafe extends GraphQLError {
-}
-
-export { RumbleError, RumbleErrorSafe, assertFindFirstExists, assertFirstEntryExists, generateFromSchema, makeLiveQuery, makeMutation, makeQuery, makeSubscription, mapNullFieldsToUndefined, rumble };