@constructive-io/react 0.20.3 → 0.20.5

package/esm/public/hooks/queries/useAppLimitWarningQuery.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { AppLimitWarningSelect, AppLimitWarningWithRelations } from '../../orm/input-types';
+import type { InferSelectResult, HookStrictSelect } from '../../orm/select-types';
+export type { AppLimitWarningSelect, AppLimitWarningWithRelations } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const appLimitWarningQueryKey: (id: string | number) => readonly ["applimitwarning", "detail", string | number];
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useAppLimitWarningQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true, name: true } },
+ * });
+ * ```
+ */
+export declare function useAppLimitWarningQuery<S extends AppLimitWarningSelect, TData = {
+    appLimitWarning: InferSelectResult<AppLimitWarningWithRelations, S> | null;
+}>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, AppLimitWarningSelect>;
+} & Omit<UseQueryOptions<{
+    appLimitWarning: InferSelectResult<AppLimitWarningWithRelations, S> | null;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * const data = await fetchAppLimitWarningQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true } },
+ * });
+ * ```
+ */
+export declare function fetchAppLimitWarningQuery<S extends AppLimitWarningSelect>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, AppLimitWarningSelect>;
+}): Promise<{
+    appLimitWarning: InferSelectResult<AppLimitWarningWithRelations, S> | null;
+}>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * await prefetchAppLimitWarningQuery(queryClient, { id: 'some-id', selection: { fields: { id: true } } });
+ * ```
+ */
+export declare function prefetchAppLimitWarningQuery<S extends AppLimitWarningSelect>(queryClient: QueryClient, params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, AppLimitWarningSelect>;
+}): Promise<void>;

package/esm/{admin/hooks/queries/useAppAchievementQuery.js → public/hooks/queries/useAppLimitWarningQuery.js}

@@ -1,22 +1,22 @@
 /**
- * Aggregated user progress for level requirements, tallying the total count; updated via triggers and should not be modified manually
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
  * @generated by @constructive-io/graphql-codegen
  * DO NOT EDIT - changes will be overwritten
  */
 import { useQuery } from '@tanstack/react-query';
 import { getClient } from '../client';
 import { buildSelectionArgs } from '../selection';
-import { appAchievementKeys } from '../query-keys';
+import { appLimitWarningKeys } from '../query-keys';
 /** Query key factory - re-exported from query-keys.ts */
-export const appAchievementQueryKey = appAchievementKeys.detail;
-export function useAppAchievementQuery(params) {
+export const appLimitWarningQueryKey = appLimitWarningKeys.detail;
+export function useAppLimitWarningQuery(params) {
     const args = buildSelectionArgs(params.selection);
     const { selection: _selection, ...queryOptions } = params ?? {};
     void _selection;
     return useQuery({
-        queryKey: appAchievementKeys.detail(params.id),
+        queryKey: appLimitWarningKeys.detail(params.id),
         queryFn: () => getClient()
-            .appAchievement.findOne({
+            .appLimitWarning.findOne({
             id: params.id,
             select: args.select,
         })
@@ -24,21 +24,21 @@ export function useAppAchievementQuery(params) {
         ...queryOptions,
     });
 }
-export async function fetchAppAchievementQuery(params) {
+export async function fetchAppLimitWarningQuery(params) {
     const args = buildSelectionArgs(params.selection);
     return getClient()
-        .appAchievement.findOne({
+        .appLimitWarning.findOne({
         id: params.id,
         select: args.select,
     })
         .unwrap();
 }
-export async function prefetchAppAchievementQuery(queryClient, params) {
+export async function prefetchAppLimitWarningQuery(queryClient, params) {
     const args = buildSelectionArgs(params.selection);
     await queryClient.prefetchQuery({
-        queryKey: appAchievementKeys.detail(params.id),
+        queryKey: appLimitWarningKeys.detail(params.id),
         queryFn: () => getClient()
-            .appAchievement.findOne({
+            .appLimitWarning.findOne({
             id: params.id,
             select: args.select,
         })

package/esm/public/hooks/queries/useAppLimitWarningsQuery.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { ListSelectionConfig } from '../selection';
+import type { AppLimitWarningSelect, AppLimitWarningWithRelations, AppLimitWarningFilter, AppLimitWarningOrderBy } from '../../orm/input-types';
+import type { InferSelectResult, ConnectionResult, HookStrictSelect } from '../../orm/select-types';
+export type { AppLimitWarningSelect, AppLimitWarningWithRelations, AppLimitWarningFilter, AppLimitWarningOrderBy, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const appLimitWarningsQueryKey: (variables?: object) => readonly ["applimitwarning", "list", object];
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useAppLimitWarningsQuery({
+ *   selection: {
+ *     fields: { id: true, name: true },
+ *     where: { name: { equalTo: "example" } },
+ *     orderBy: ['CREATED_AT_DESC'],
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function useAppLimitWarningsQuery<S extends AppLimitWarningSelect, TData = {
+    appLimitWarnings: ConnectionResult<InferSelectResult<AppLimitWarningWithRelations, S>>;
+}>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, AppLimitWarningFilter, AppLimitWarningOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, AppLimitWarningSelect>;
+} & Omit<UseQueryOptions<{
+    appLimitWarnings: ConnectionResult<InferSelectResult<AppLimitWarningWithRelations, S>>;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * const data = await fetchAppLimitWarningsQuery({
+ *   selection: {
+ *     fields: { id: true },
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function fetchAppLimitWarningsQuery<S extends AppLimitWarningSelect>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, AppLimitWarningFilter, AppLimitWarningOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, AppLimitWarningSelect>;
+}): Promise<{
+    appLimitWarnings: ConnectionResult<InferSelectResult<AppLimitWarningWithRelations, S>>;
+}>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * await prefetchAppLimitWarningsQuery(queryClient, { selection: { fields: { id: true }, first: 10 } });
+ * ```
+ */
+export declare function prefetchAppLimitWarningsQuery<S extends AppLimitWarningSelect>(queryClient: QueryClient, params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, AppLimitWarningFilter, AppLimitWarningOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, AppLimitWarningSelect>;
+}): Promise<void>;

package/esm/public/hooks/queries/useAppLimitWarningsQuery.js

@@ -0,0 +1,32 @@
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildListSelectionArgs } from '../selection';
+import { appLimitWarningKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const appLimitWarningsQueryKey = appLimitWarningKeys.list;
+export function useAppLimitWarningsQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: appLimitWarningKeys.list(args),
+        queryFn: () => getClient().appLimitWarning.findMany(args).unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchAppLimitWarningsQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    return getClient().appLimitWarning.findMany(args).unwrap();
+}
+export async function prefetchAppLimitWarningsQuery(queryClient, params) {
+    const args = buildListSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: appLimitWarningKeys.list(args),
+        queryFn: () => getClient().appLimitWarning.findMany(args).unwrap(),
+    });
+}

package/esm/public/hooks/queries/useEventsModuleQuery.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Single item query hook for EventsModule
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { EventsModuleSelect, EventsModuleWithRelations } from '../../orm/input-types';
+import type { InferSelectResult, HookStrictSelect } from '../../orm/select-types';
+export type { EventsModuleSelect, EventsModuleWithRelations } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const eventsModuleQueryKey: (id: string | number) => readonly ["eventsmodule", "detail", string | number];
+/**
+ * Query hook for fetching a single EventsModule
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useEventsModuleQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true, name: true } },
+ * });
+ * ```
+ */
+export declare function useEventsModuleQuery<S extends EventsModuleSelect, TData = {
+    eventsModule: InferSelectResult<EventsModuleWithRelations, S> | null;
+}>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, EventsModuleSelect>;
+} & Omit<UseQueryOptions<{
+    eventsModule: InferSelectResult<EventsModuleWithRelations, S> | null;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Fetch a single EventsModule without React hooks
+ *
+ * @example
+ * ```ts
+ * const data = await fetchEventsModuleQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true } },
+ * });
+ * ```
+ */
+export declare function fetchEventsModuleQuery<S extends EventsModuleSelect>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, EventsModuleSelect>;
+}): Promise<{
+    eventsModule: InferSelectResult<EventsModuleWithRelations, S> | null;
+}>;
+/**
+ * Prefetch a single EventsModule for SSR or cache warming
+ *
+ * @example
+ * ```ts
+ * await prefetchEventsModuleQuery(queryClient, { id: 'some-id', selection: { fields: { id: true } } });
+ * ```
+ */
+export declare function prefetchEventsModuleQuery<S extends EventsModuleSelect>(queryClient: QueryClient, params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, EventsModuleSelect>;
+}): Promise<void>;

package/esm/public/hooks/queries/{useLevelsModuleQuery.js → useEventsModuleQuery.js}

@@ -1,22 +1,22 @@
 /**
- * Single item query hook for LevelsModule
+ * Single item query hook for EventsModule
  * @generated by @constructive-io/graphql-codegen
  * DO NOT EDIT - changes will be overwritten
  */
 import { useQuery } from '@tanstack/react-query';
 import { getClient } from '../client';
 import { buildSelectionArgs } from '../selection';
-import { levelsModuleKeys } from '../query-keys';
+import { eventsModuleKeys } from '../query-keys';
 /** Query key factory - re-exported from query-keys.ts */
-export const levelsModuleQueryKey = levelsModuleKeys.detail;
-export function useLevelsModuleQuery(params) {
+export const eventsModuleQueryKey = eventsModuleKeys.detail;
+export function useEventsModuleQuery(params) {
     const args = buildSelectionArgs(params.selection);
     const { selection: _selection, ...queryOptions } = params ?? {};
     void _selection;
     return useQuery({
-        queryKey: levelsModuleKeys.detail(params.id),
+        queryKey: eventsModuleKeys.detail(params.id),
         queryFn: () => getClient()
-            .levelsModule.findOne({
+            .eventsModule.findOne({
             id: params.id,
             select: args.select,
         })
@@ -24,21 +24,21 @@ export function useLevelsModuleQuery(params) {
         ...queryOptions,
     });
 }
-export async function fetchLevelsModuleQuery(params) {
+export async function fetchEventsModuleQuery(params) {
     const args = buildSelectionArgs(params.selection);
     return getClient()
-        .levelsModule.findOne({
+        .eventsModule.findOne({
         id: params.id,
         select: args.select,
     })
         .unwrap();
 }
-export async function prefetchLevelsModuleQuery(queryClient, params) {
+export async function prefetchEventsModuleQuery(queryClient, params) {
     const args = buildSelectionArgs(params.selection);
     await queryClient.prefetchQuery({
-        queryKey: levelsModuleKeys.detail(params.id),
+        queryKey: eventsModuleKeys.detail(params.id),
         queryFn: () => getClient()
-            .levelsModule.findOne({
+            .eventsModule.findOne({
             id: params.id,
             select: args.select,
         })

package/esm/public/hooks/queries/useEventsModulesQuery.d.ts

@@ -0,0 +1,69 @@
+/**
+ * List query hook for EventsModule
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { ListSelectionConfig } from '../selection';
+import type { EventsModuleSelect, EventsModuleWithRelations, EventsModuleFilter, EventsModuleOrderBy } from '../../orm/input-types';
+import type { InferSelectResult, ConnectionResult, HookStrictSelect } from '../../orm/select-types';
+export type { EventsModuleSelect, EventsModuleWithRelations, EventsModuleFilter, EventsModuleOrderBy, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const eventsModulesQueryKey: (variables?: object) => readonly ["eventsmodule", "list", object];
+/**
+ * Query hook for fetching EventsModule list
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useEventsModulesQuery({
+ *   selection: {
+ *     fields: { id: true, name: true },
+ *     where: { name: { equalTo: "example" } },
+ *     orderBy: ['CREATED_AT_DESC'],
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function useEventsModulesQuery<S extends EventsModuleSelect, TData = {
+    eventsModules: ConnectionResult<InferSelectResult<EventsModuleWithRelations, S>>;
+}>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, EventsModuleFilter, EventsModuleOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, EventsModuleSelect>;
+} & Omit<UseQueryOptions<{
+    eventsModules: ConnectionResult<InferSelectResult<EventsModuleWithRelations, S>>;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Fetch EventsModule list without React hooks
+ *
+ * @example
+ * ```ts
+ * const data = await fetchEventsModulesQuery({
+ *   selection: {
+ *     fields: { id: true },
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function fetchEventsModulesQuery<S extends EventsModuleSelect>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, EventsModuleFilter, EventsModuleOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, EventsModuleSelect>;
+}): Promise<{
+    eventsModules: ConnectionResult<InferSelectResult<EventsModuleWithRelations, S>>;
+}>;
+/**
+ * Prefetch EventsModule list for SSR or cache warming
+ *
+ * @example
+ * ```ts
+ * await prefetchEventsModulesQuery(queryClient, { selection: { fields: { id: true }, first: 10 } });
+ * ```
+ */
+export declare function prefetchEventsModulesQuery<S extends EventsModuleSelect>(queryClient: QueryClient, params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, EventsModuleFilter, EventsModuleOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, EventsModuleSelect>;
+}): Promise<void>;

package/esm/public/hooks/queries/{useLevelsModulesQuery.js → useEventsModulesQuery.js}

@@ -1,32 +1,32 @@
 /**
- * List query hook for LevelsModule
+ * List query hook for EventsModule
  * @generated by @constructive-io/graphql-codegen
  * DO NOT EDIT - changes will be overwritten
  */
 import { useQuery } from '@tanstack/react-query';
 import { getClient } from '../client';
 import { buildListSelectionArgs } from '../selection';
-import { levelsModuleKeys } from '../query-keys';
+import { eventsModuleKeys } from '../query-keys';
 /** Query key factory - re-exported from query-keys.ts */
-export const levelsModulesQueryKey = levelsModuleKeys.list;
-export function useLevelsModulesQuery(params) {
+export const eventsModulesQueryKey = eventsModuleKeys.list;
+export function useEventsModulesQuery(params) {
     const args = buildListSelectionArgs(params.selection);
     const { selection: _selection, ...queryOptions } = params ?? {};
     void _selection;
     return useQuery({
-        queryKey: levelsModuleKeys.list(args),
-        queryFn: () => getClient().levelsModule.findMany(args).unwrap(),
+        queryKey: eventsModuleKeys.list(args),
+        queryFn: () => getClient().eventsModule.findMany(args).unwrap(),
         ...queryOptions,
     });
 }
-export async function fetchLevelsModulesQuery(params) {
+export async function fetchEventsModulesQuery(params) {
     const args = buildListSelectionArgs(params.selection);
-    return getClient().levelsModule.findMany(args).unwrap();
+    return getClient().eventsModule.findMany(args).unwrap();
 }
-export async function prefetchLevelsModulesQuery(queryClient, params) {
+export async function prefetchEventsModulesQuery(queryClient, params) {
     const args = buildListSelectionArgs(params.selection);
     await queryClient.prefetchQuery({
-        queryKey: levelsModuleKeys.list(args),
-        queryFn: () => getClient().levelsModule.findMany(args).unwrap(),
+        queryKey: eventsModuleKeys.list(args),
+        queryFn: () => getClient().eventsModule.findMany(args).unwrap(),
     });
 }

package/esm/public/hooks/queries/useOrgLimitWarningQuery.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { OrgLimitWarningSelect, OrgLimitWarningWithRelations } from '../../orm/input-types';
+import type { InferSelectResult, HookStrictSelect } from '../../orm/select-types';
+export type { OrgLimitWarningSelect, OrgLimitWarningWithRelations } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const orgLimitWarningQueryKey: (id: string | number) => readonly ["orglimitwarning", "detail", string | number];
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useOrgLimitWarningQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true, name: true } },
+ * });
+ * ```
+ */
+export declare function useOrgLimitWarningQuery<S extends OrgLimitWarningSelect, TData = {
+    orgLimitWarning: InferSelectResult<OrgLimitWarningWithRelations, S> | null;
+}>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, OrgLimitWarningSelect>;
+} & Omit<UseQueryOptions<{
+    orgLimitWarning: InferSelectResult<OrgLimitWarningWithRelations, S> | null;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * const data = await fetchOrgLimitWarningQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true } },
+ * });
+ * ```
+ */
+export declare function fetchOrgLimitWarningQuery<S extends OrgLimitWarningSelect>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, OrgLimitWarningSelect>;
+}): Promise<{
+    orgLimitWarning: InferSelectResult<OrgLimitWarningWithRelations, S> | null;
+}>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * await prefetchOrgLimitWarningQuery(queryClient, { id: 'some-id', selection: { fields: { id: true } } });
+ * ```
+ */
+export declare function prefetchOrgLimitWarningQuery<S extends OrgLimitWarningSelect>(queryClient: QueryClient, params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, OrgLimitWarningSelect>;
+}): Promise<void>;

package/esm/public/hooks/queries/useOrgLimitWarningQuery.js

@@ -0,0 +1,47 @@
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildSelectionArgs } from '../selection';
+import { orgLimitWarningKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const orgLimitWarningQueryKey = orgLimitWarningKeys.detail;
+export function useOrgLimitWarningQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: orgLimitWarningKeys.detail(params.id),
+        queryFn: () => getClient()
+            .orgLimitWarning.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchOrgLimitWarningQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    return getClient()
+        .orgLimitWarning.findOne({
+        id: params.id,
+        select: args.select,
+    })
+        .unwrap();
+}
+export async function prefetchOrgLimitWarningQuery(queryClient, params) {
+    const args = buildSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: orgLimitWarningKeys.detail(params.id),
+        queryFn: () => getClient()
+            .orgLimitWarning.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+    });
+}

package/esm/public/hooks/queries/useOrgLimitWarningsQuery.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { ListSelectionConfig } from '../selection';
+import type { OrgLimitWarningSelect, OrgLimitWarningWithRelations, OrgLimitWarningFilter, OrgLimitWarningOrderBy } from '../../orm/input-types';
+import type { InferSelectResult, ConnectionResult, HookStrictSelect } from '../../orm/select-types';
+export type { OrgLimitWarningSelect, OrgLimitWarningWithRelations, OrgLimitWarningFilter, OrgLimitWarningOrderBy, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const orgLimitWarningsQueryKey: (variables?: object) => readonly ["orglimitwarning", "list", object];
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useOrgLimitWarningsQuery({
+ *   selection: {
+ *     fields: { id: true, name: true },
+ *     where: { name: { equalTo: "example" } },
+ *     orderBy: ['CREATED_AT_DESC'],
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function useOrgLimitWarningsQuery<S extends OrgLimitWarningSelect, TData = {
+    orgLimitWarnings: ConnectionResult<InferSelectResult<OrgLimitWarningWithRelations, S>>;
+}>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, OrgLimitWarningFilter, OrgLimitWarningOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, OrgLimitWarningSelect>;
+} & Omit<UseQueryOptions<{
+    orgLimitWarnings: ConnectionResult<InferSelectResult<OrgLimitWarningWithRelations, S>>;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * const data = await fetchOrgLimitWarningsQuery({
+ *   selection: {
+ *     fields: { id: true },
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function fetchOrgLimitWarningsQuery<S extends OrgLimitWarningSelect>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, OrgLimitWarningFilter, OrgLimitWarningOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, OrgLimitWarningSelect>;
+}): Promise<{
+    orgLimitWarnings: ConnectionResult<InferSelectResult<OrgLimitWarningWithRelations, S>>;
+}>;
+/**
+ * Warning configuration for soft limits. Each row defines a warning threshold and the job task to enqueue when usage approaches it.
+ *
+ * @example
+ * ```ts
+ * await prefetchOrgLimitWarningsQuery(queryClient, { selection: { fields: { id: true }, first: 10 } });
+ * ```
+ */
+export declare function prefetchOrgLimitWarningsQuery<S extends OrgLimitWarningSelect>(queryClient: QueryClient, params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, OrgLimitWarningFilter, OrgLimitWarningOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, OrgLimitWarningSelect>;
+}): Promise<void>;