kitcn/dist/generated-contract-disabled-C_-KWRfT.d.ts

kitcn - React Query integration and CLI tools for Convex

import { t as GetAuth } from "./types-BCl8gfGy.js";
import { t as GenericCtx } from "./context-utils-OMkMGhBk.js";
import * as convex_server0 from "convex/server";
import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericSchema, SchemaDefinition, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
import * as better_auth_adapters0 from "better-auth/adapters";
import { BetterAuthOptions } from "better-auth/minimal";
import { Auth } from "better-auth";

//#region src/auth/define-auth.d.ts
type MaybePromise$1<T> = T | Promise<T>;
type TableDoc<DataModel extends GenericDataModel, TableName extends string> = TableName extends TableNamesInDataModel<DataModel> ? DocumentByName<DataModel, TableName> extends Record<string, unknown> ? DocumentByName<DataModel, TableName> : Record<string, unknown> : Record<string, unknown>;
type InsertDocData<TDoc extends Record<string, unknown>> = Omit<TDoc, '_id' | '_creationTime'>;
type UpdateDocData<TDoc extends Record<string, unknown>> = Partial<Omit<TDoc, '_id' | '_creationTime'>>;
type TriggerChangeId<TDoc> = TDoc extends {
  _id: infer TId;
} ? TId : TDoc extends {
  id: infer TId;
} ? TId : unknown;
type GenericAuthTriggerChange<TDoc extends Record<string, unknown> = Record<string, unknown>, TId = TriggerChangeId<TDoc>> = {
  id: TId;
  newDoc: TDoc;
  oldDoc: null;
  operation: 'insert';
} | {
  id: TId;
  newDoc: TDoc;
  oldDoc: TDoc;
  operation: 'update';
} | {
  id: TId;
  newDoc: null;
  oldDoc: TDoc;
  operation: 'delete';
};
type GenericAuthBeforeResult<TData extends Record<string, unknown>> = void | false | {
  data: Partial<TData>;
};
type GenericAuthTriggerHandlers<DataModel extends GenericDataModel, TableName extends string, TriggerCtx, Doc extends Record<string, unknown> = TableDoc<DataModel, TableName>, InsertDoc extends Record<string, unknown> = InsertDocData<Doc>, UpdateDoc extends Record<string, unknown> = UpdateDocData<Doc>> = {
  change?: (change: GenericAuthTriggerChange<Doc>, ctx: TriggerCtx) => MaybePromise$1<void>;
  create?: {
    after?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
    before?: (data: InsertDoc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<InsertDoc>>;
  };
  delete?: {
    after?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
    before?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<Doc>>;
  };
  update?: {
    after?: (newDoc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
    before?: (update: UpdateDoc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<UpdateDoc>>;
  };
};
type GenericAuthTriggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx = unknown> = { [K in keyof Schema['tables'] & string]?: GenericAuthTriggerHandlers<DataModel, K, TriggerCtx> };
type BetterAuthOptionsWithoutDatabase = Omit<BetterAuthOptions, 'database'>;
type GenericAuthDefinition<GenericCtx = unknown, DataModel extends GenericDataModel = GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true> = SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase> = (ctx: GenericCtx) => AuthOptions & {
  triggers?: GenericAuthTriggers<DataModel, Schema, GenericCtx>;
};
declare const defineAuth: <GenericCtx = unknown, DataModel extends GenericDataModel = GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true> = SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase>(definition: GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions>) => GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions>;
//#endregion
//#region src/auth/create-api.d.ts
type Schema = SchemaDefinition<any, any>;
type MaybePromise<T> = T | Promise<T>;
type RuntimeBeforeResult = GenericAuthBeforeResult<Record<string, unknown>>;
type RuntimeTriggerChange = GenericAuthTriggerChange<Record<string, unknown>>;
type RuntimeTableTriggers = {
  change?: (change: RuntimeTriggerChange, ctx: unknown) => MaybePromise<void>;
  create?: {
    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
    before?: (data: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
  };
  delete?: {
    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
    before?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
  };
  update?: {
    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
    before?: (update: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
  };
};
declare const createHandler: (ctx: any, args: {
  input: {
    data: any;
    model: string;
  };
  select?: string[];
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<any>;
declare const findOneHandler: (ctx: any, args: {
  model: string;
  select?: string[];
  where?: any[];
}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.GenericDocument | null>;
declare const findManyHandler: (ctx: any, args: {
  model: string;
  paginationOpts: any;
  limit?: number;
  offset?: number;
  sortBy?: {
    direction: "asc" | "desc";
    field: string;
  };
  where?: any[];
}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>;
declare const updateOneHandler: (ctx: any, args: {
  input: {
    model: string;
    update: any;
    where?: any[];
  };
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<any>;
declare const updateManyHandler: (ctx: any, args: {
  input: {
    model: string;
    update?: any;
    where?: any[];
  };
  paginationOpts: any;
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<{
  count: number;
  ids: any[];
  isDone: boolean;
  continueCursor: convex_server0.Cursor;
  splitCursor?: convex_server0.Cursor | null;
  pageStatus?: "SplitRecommended" | "SplitRequired" | null;
}>;
declare const deleteOneHandler: (ctx: any, args: {
  input: {
    model: string;
    where?: any[];
  };
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<Record<string, unknown> | undefined>;
declare const deleteManyHandler: (ctx: any, args: {
  input: {
    model: string;
    where?: any[];
  };
  paginationOpts: any;
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<{
  count: number;
  ids: any[];
  isDone: boolean;
  continueCursor: convex_server0.Cursor;
  splitCursor?: convex_server0.Cursor | null;
  pageStatus?: "SplitRecommended" | "SplitRequired" | null;
}>;
declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel extends GenericDataModel = GenericDataModel, Ctx = unknown, TriggerCtx = Ctx, Auth = unknown>(schema: Schema, getAuth: GetAuth<Ctx, Auth>, options?: {
  internalMutation?: typeof internalMutationGeneric;
  context?: (ctx: any) => TriggerCtx | Promise<TriggerCtx>;
  triggers?: GenericAuthTriggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => GenericAuthTriggers<DataModel, Schema, TriggerCtx> | undefined); /** Validate input validators against auth table schemas. Defaults to false for smaller generated types. */
  validateInput?: boolean;
}) => {
  create: convex_server0.RegisteredMutation<"internal", {
    select?: string[] | undefined;
    input: {
      data: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
      model: string;
    } | {
      data: any;
      model: string;
    };
  }, Promise<any>>;
  deleteMany: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        connector?: "AND" | "OR" | undefined;
        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
    } | {
      where?: any[] | undefined;
      model: string;
    };
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
  }, Promise<{
    count: number;
    ids: any[];
    isDone: boolean;
    continueCursor: convex_server0.Cursor;
    splitCursor?: convex_server0.Cursor | null;
    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
  }>>;
  deleteOne: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        connector?: "AND" | "OR" | undefined;
        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
    } | {
      where?: any[] | undefined;
      model: string;
    };
  }, Promise<Record<string, unknown> | undefined>>;
  findMany: convex_server0.RegisteredQuery<"internal", {
    join?: any;
    where?: {
      mode?: "sensitive" | "insensitive" | undefined;
      connector?: "AND" | "OR" | undefined;
      operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
      value: string | number | boolean | string[] | number[] | null;
      field: string;
    }[] | undefined;
    limit?: number | undefined;
    offset?: number | undefined;
    sortBy?: {
      field: string;
      direction: "asc" | "desc";
    } | undefined;
    model: string;
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
  }, Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>>;
  findOne: convex_server0.RegisteredQuery<"internal", {
    join?: any;
    select?: string[] | undefined;
    where?: {
      mode?: "sensitive" | "insensitive" | undefined;
      connector?: "AND" | "OR" | undefined;
      operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
      value: string | number | boolean | string[] | number[] | null;
      field: string;
    }[] | undefined;
    model: string;
  }, Promise<convex_server0.GenericDocument | null>>;
  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
  updateMany: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        connector?: "AND" | "OR" | undefined;
        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
      update: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
    } | {
      where?: any[] | undefined;
      model: string;
      update: any;
    };
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
  }, Promise<{
    count: number;
    ids: any[];
    isDone: boolean;
    continueCursor: convex_server0.Cursor;
    splitCursor?: convex_server0.Cursor | null;
    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
  }>>;
  updateOne: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        connector?: "AND" | "OR" | undefined;
        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
      update: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
    } | {
      where?: any[] | undefined;
      model: string;
      update: any;
    };
  }, Promise<any>>;
};
//#endregion
//#region src/auth/create-client.d.ts
type AuthFunctions = {
  create: FunctionReference<'mutation', 'internal', Record<string, any>>;
  deleteMany: FunctionReference<'mutation', 'internal', Record<string, any>>;
  deleteOne: FunctionReference<'mutation', 'internal', Record<string, any>>;
  findMany: FunctionReference<'query', 'internal', Record<string, any>>;
  findOne: FunctionReference<'query', 'internal', Record<string, any>>;
  updateMany: FunctionReference<'mutation', 'internal', Record<string, any>>;
  updateOne: FunctionReference<'mutation', 'internal', Record<string, any>>;
};
type Triggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx = unknown> = GenericAuthTriggers<DataModel, Schema, TriggerCtx>;
type TriggerResolver<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>> = Triggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => Triggers<DataModel, Schema, TriggerCtx> | undefined);
declare const createClient: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>>(config: {
  authFunctions: AuthFunctions;
  schema: Schema;
  context?: (ctx: GenericMutationCtx<DataModel>) => TriggerCtx | Promise<TriggerCtx>;
  triggers?: TriggerResolver<DataModel, Schema, TriggerCtx>;
}) => {
  authFunctions: AuthFunctions;
  triggers: TriggerResolver<DataModel, Schema, TriggerCtx> | undefined;
  adapter: (ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
};
//#endregion
//#region src/auth/generated-contract-disabled.d.ts
type GeneratedAuthDisabledReasonKind = 'default_export_unavailable' | 'missing_auth_file' | 'missing_default_export';
declare const getGeneratedAuthDisabledReason: (kind: GeneratedAuthDisabledReasonKind, authDefinitionPath?: string) => string;
type AuthRuntime<DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>, GenericCtx = GenericMutationCtx<DataModel>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase> = {
  auth: Auth<AuthOptions & {
    database: BetterAuthOptions['database'];
  }>;
  authClient: ReturnType<typeof createClient<DataModel, Schema, TriggerCtx>>;
  authEnabled: boolean;
  getAuth: (ctx: GenericCtx) => Auth<AuthOptions & {
    database: BetterAuthOptions['database'];
  }>;
} & ReturnType<typeof createApi<Schema, DataModel, GenericCtx, TriggerCtx, Auth<AuthOptions & {
  database: BetterAuthOptions['database'];
}>>>;
declare const createDisabledAuthRuntime: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>, GenericCtx = GenericMutationCtx<DataModel>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase>(config?: {
  reason?: string;
}) => AuthRuntime<DataModel, Schema, TriggerCtx, GenericCtx, AuthOptions>;
//#endregion
export { defineAuth as S, GenericAuthBeforeResult as _, AuthFunctions as a, GenericAuthTriggerHandlers as b, createApi as c, deleteOneHandler as d, findManyHandler as f, BetterAuthOptionsWithoutDatabase as g, updateOneHandler as h, getGeneratedAuthDisabledReason as i, createHandler as l, updateManyHandler as m, GeneratedAuthDisabledReasonKind as n, Triggers as o, findOneHandler as p, createDisabledAuthRuntime as r, createClient as s, AuthRuntime as t, deleteManyHandler as u, GenericAuthDefinition as v, GenericAuthTriggers as x, GenericAuthTriggerChange as y };