@constructive-io/sdk 1.19.2 → 1.19.3

package/storage/orm/realtime.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Realtime Manager - WebSocket subscription support
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+interface WsGraphQLError {
+    readonly message: string;
+    readonly [key: string]: unknown;
+}
+interface WsExecutionResult<TData = Record<string, unknown>> {
+    data?: TData | null;
+    errors?: readonly WsGraphQLError[];
+    extensions?: Record<string, unknown>;
+}
+interface WsSink<T> {
+    next(value: T): void;
+    error(error: unknown): void;
+    complete(): void;
+}
+/**
+ * Minimal interface matching the graphql-ws Client.
+ * Consumers pass a concrete instance via RealtimeConfig.client.
+ */
+export interface WsClient {
+    subscribe<TData = Record<string, unknown>>(payload: {
+        query: string;
+        variables?: Record<string, unknown>;
+    }, sink: WsSink<WsExecutionResult<TData>>): () => void;
+    dispose(): void;
+}
+/** The DML operation that triggered the subscription event */
+export type SubscriptionOperation = 'INSERT' | 'UPDATE' | 'DELETE';
+/** Connection state of the WebSocket */
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/** Listener for connection state changes */
+export type ConnectionStateListener = (state: ConnectionState) => void;
+/** Function returned by subscribe() to cancel the subscription */
+export type Unsubscribe = () => void;
+/**
+ * A realtime subscription event delivered to the client.
+ *
+ * @typeParam T - The row type of the subscribed table
+ */
+export interface SubscriptionEvent<T> {
+    /** The DML operation that triggered this event */
+    operation: SubscriptionOperation;
+    /** The current row data (null for DELETE if row is no longer visible) */
+    data: T | null;
+    /** Previous field values (populated on UPDATE when available) */
+    previousValues?: Partial<T>;
+    /** Server-side timestamp of when the change occurred */
+    timestamp: string;
+}
+/**
+ * Options for creating a subscription.
+ *
+ * @typeParam T - The row type of the subscribed table
+ * @typeParam TFilter - The filter type for the table
+ */
+export interface SubscribeOptions<T, TFilter = Record<string, unknown>> {
+    /** Server-side filter to limit which events are delivered */
+    filter?: TFilter;
+    /** Called when a subscription event is received */
+    onEvent: (event: SubscriptionEvent<T>) => void;
+    /** Called when the subscription encounters an error */
+    onError?: (error: Error) => void;
+    /** Called when the subscription completes (server-initiated close) */
+    onComplete?: () => void;
+}
+/**
+ * Metadata about a subscription field, used internally to map
+ * table names to GraphQL subscription field names and types.
+ */
+export interface SubscriptionFieldMeta {
+    /** The GraphQL subscription field name (e.g., 'onContactChanged') */
+    fieldName: string;
+    /** The table name in the source schema (e.g., 'contact') */
+    tableName: string;
+    /** The data field name inside the subscription payload (e.g., 'contact') */
+    dataFieldName: string;
+}
+/**
+ * Configuration for the realtime (WebSocket) connection.
+ * Pass this as the `realtime` option in OrmClientConfig.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'graphql-ws';
+ *
+ * const client = createOrmClient({
+ *   endpoint: 'https://api.example.com/graphql',
+ *   realtime: {
+ *     client: createClient({ url: 'wss://api.example.com/graphql' }),
+ *   },
+ * });
+ * ```
+ */
+export interface RealtimeConfig {
+    /**
+     * A graphql-ws Client instance (or any object satisfying WsClient).
+     * The consumer creates this themselves, giving full control over
+     * connection options, auth, and transport.
+     *
+     * @example
+     * ```ts
+     * import { createClient } from 'graphql-ws';
+     * const wsClient = createClient({ url: 'wss://...' });
+     * ```
+     */
+    client: WsClient;
+}
+/**
+ * Manages a graphql-ws WebSocket client and multiplexes
+ * subscriptions over it. Created by OrmClient when `realtime`
+ * config is provided.
+ */
+export declare class RealtimeManager {
+    private wsClient;
+    private connectionState;
+    private stateListeners;
+    private activeSubscriptions;
+    constructor(config: RealtimeConfig);
+    /**
+     * Subscribe to a GraphQL subscription operation.
+     * Models call this with typed metadata and documents.
+     */
+    subscribe<T>(meta: SubscriptionFieldMeta, document: string, variables: Record<string, unknown>, options: {
+        onEvent: (event: SubscriptionEvent<T>) => void;
+        onError?: (error: Error) => void;
+        onComplete?: () => void;
+    }): Unsubscribe;
+    /** Register a listener for connection state changes */
+    onConnectionStateChange(listener: ConnectionStateListener): Unsubscribe;
+    /** Get current connection state */
+    getConnectionState(): ConnectionState;
+    /** Number of active subscriptions */
+    getActiveSubscriptionCount(): number;
+    /** Dispose the manager and close the WebSocket connection */
+    dispose(): void;
+    private setConnectionState;
+}
+export {};

package/storage/orm/realtime.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Realtime Manager - WebSocket subscription support
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+// Minimal type shims so this module compiles without graphql-ws
+// installed.  Consumers supply a WsClient via RealtimeConfig;
+// the SDK itself never imports or requires graphql-ws.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeManager = void 0;
+// ============================================================================
+// RealtimeManager
+// ============================================================================
+/**
+ * Manages a graphql-ws WebSocket client and multiplexes
+ * subscriptions over it. Created by OrmClient when `realtime`
+ * config is provided.
+ */
+class RealtimeManager {
+    wsClient;
+    connectionState = 'disconnected';
+    stateListeners = new Set();
+    activeSubscriptions = 0;
+    constructor(config) {
+        this.wsClient = config.client;
+    }
+    /**
+     * Subscribe to a GraphQL subscription operation.
+     * Models call this with typed metadata and documents.
+     */
+    subscribe(meta, document, variables, options) {
+        this.activeSubscriptions++;
+        let disposed = false;
+        const cleanup = this.wsClient.subscribe({ query: document, variables }, {
+            next: (result) => {
+                if (disposed)
+                    return;
+                if (result.errors) {
+                    options.onError?.(new Error(result.errors.map((e) => e.message).join('; ')));
+                    return;
+                }
+                const payload = result.data?.[meta.fieldName];
+                if (!payload)
+                    return;
+                const event = {
+                    operation: payload.event ?? 'UPDATE',
+                    data: payload[meta.dataFieldName] ?? null,
+                    previousValues: payload.previousValues,
+                    timestamp: payload.timestamp ?? new Date().toISOString(),
+                };
+                options.onEvent(event);
+            },
+            error: (err) => {
+                if (disposed)
+                    return;
+                options.onError?.(err instanceof Error ? err : new Error(String(err)));
+            },
+            complete: () => {
+                if (disposed)
+                    return;
+                options.onComplete?.();
+            },
+        });
+        return () => {
+            if (disposed)
+                return;
+            disposed = true;
+            this.activeSubscriptions--;
+            cleanup();
+        };
+    }
+    /** Register a listener for connection state changes */
+    onConnectionStateChange(listener) {
+        this.stateListeners.add(listener);
+        return () => {
+            this.stateListeners.delete(listener);
+        };
+    }
+    /** Get current connection state */
+    getConnectionState() {
+        return this.connectionState;
+    }
+    /** Number of active subscriptions */
+    getActiveSubscriptionCount() {
+        return this.activeSubscriptions;
+    }
+    /** Dispose the manager and close the WebSocket connection */
+    dispose() {
+        this.wsClient.dispose();
+        this.stateListeners.clear();
+        this.activeSubscriptions = 0;
+        this.setConnectionState('disconnected');
+    }
+    setConnectionState(state) {
+        if (this.connectionState === state)
+            return;
+        this.connectionState = state;
+        for (const listener of this.stateListeners) {
+            listener(state);
+        }
+    }
+}
+exports.RealtimeManager = RealtimeManager;

package/storage/orm/select-types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Type utilities for select inference
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+export interface ConnectionResult<T> {
+    nodes: T[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+export interface PageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string | null;
+    endCursor?: string | null;
+}
+export interface FindManyArgs<TSelect, TWhere, TOrderBy> {
+    select?: TSelect;
+    where?: TWhere;
+    orderBy?: TOrderBy[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}
+export interface FindFirstArgs<TSelect, TWhere, TOrderBy> {
+    select?: TSelect;
+    where?: TWhere;
+    orderBy?: TOrderBy[];
+}
+export interface CreateArgs<TSelect, TData> {
+    data: TData;
+    select?: TSelect;
+}
+export interface UpdateArgs<TSelect, TWhere, TData> {
+    where: TWhere;
+    data: TData;
+    select?: TSelect;
+}
+export type FindOneArgs<TSelect, TIdName extends string = 'id', TId = string> = {
+    select?: TSelect;
+} & Record<TIdName, TId>;
+export interface DeleteArgs<TWhere, TSelect = undefined> {
+    where: TWhere;
+    select?: TSelect;
+}
+export interface BulkInsertArgs<TSelect, TData, TOnConflict = unknown> {
+    data: TData[];
+    select?: TSelect;
+    onConflict?: TOnConflict;
+}
+export interface BulkUpsertArgs<TSelect, TData, TOnConflict = unknown> {
+    data: TData[];
+    select?: TSelect;
+    onConflict: TOnConflict;
+}
+export interface BulkUpdateArgs<TSelect, TWhere, TData> {
+    where: TWhere;
+    data: TData;
+    select?: TSelect;
+}
+export interface BulkDeleteArgs<TSelect, TWhere> {
+    where: TWhere;
+    select?: TSelect;
+}
+export interface BulkMutationResult<T> {
+    affectedCount: number;
+    returning: T[];
+}
+type DepthLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+type DecrementDepth = {
+    0: 0;
+    1: 0;
+    2: 1;
+    3: 2;
+    4: 3;
+    5: 4;
+    6: 5;
+    7: 6;
+    8: 7;
+    9: 8;
+    10: 9;
+};
+/**
+ * Recursively validates select objects, rejecting unknown keys.
+ *
+ * NOTE: Depth is intentionally capped to avoid circular-instantiation issues
+ * in very large cyclic schemas.
+ */
+export type DeepExact<T, Shape, Depth extends DepthLevel = 10> = Depth extends 0 ? T extends Shape ? T : never : T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? {
+    [K in keyof T]: K extends keyof Shape ? T[K] extends {
+        select: infer NS;
+    } ? Extract<Shape[K], {
+        select?: unknown;
+    }> extends {
+        select?: infer ShapeNS;
+    } ? DeepExact<Omit<T[K], 'select'> & {
+        select: DeepExact<NS, NonNullable<ShapeNS>, DecrementDepth[Depth]>;
+    }, Extract<Shape[K], {
+        select?: unknown;
+    }>, DecrementDepth[Depth]> : never : T[K] : never;
+} : never : never;
+/**
+ * Enforces exact select shape while keeping contextual typing on `S extends XxxSelect`.
+ * Use this as an intersection in overloads:
+ * `{ select: S } & StrictSelect<S, XxxSelect>`.
+ */
+export type StrictSelect<S, Shape> = S extends DeepExact<S, Shape> ? {} : never;
+/**
+ * Hook-optimized strict select variant.
+ *
+ * Uses a shallower recursion depth to keep editor autocomplete responsive
+ * in large schemas while still validating common nested-select mistakes.
+ */
+export type HookStrictSelect<S, Shape> = S extends DeepExact<S, Shape, 5> ? {} : never;
+/**
+ * Infer result type from select configuration
+ */
+export type InferSelectResult<TEntity, TSelect> = TSelect extends undefined ? TEntity : {
+    [K in keyof TSelect as TSelect[K] extends false | undefined ? never : K]: TSelect[K] extends true ? K extends keyof TEntity ? TEntity[K] : never : TSelect[K] extends {
+        select: infer NestedSelect;
+    } ? K extends keyof TEntity ? NonNullable<TEntity[K]> extends ConnectionResult<infer NodeType> ? ConnectionResult<InferSelectResult<NodeType, NestedSelect>> : InferSelectResult<NonNullable<TEntity[K]>, NestedSelect> | (null extends TEntity[K] ? null : never) : never : K extends keyof TEntity ? TEntity[K] : never;
+};
+export {};

package/storage/orm/select-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/storage/orm/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Types re-export
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+export * from './input-types';

package/storage/orm/types.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Types re-export
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all types from input-types
+__exportStar(require("./input-types"), exports);

package/usage/orm/index.d.ts

@@ -1,11 +1,4 @@
 import type { OrmClientConfig } from './client';
-import { AppAchievementRewardModel } from './models/appAchievementReward';
-import { AppEventAggregateModel } from './models/appEventAggregate';
-import { AppEventModel } from './models/appEvent';
-import { AppEventTypeModel } from './models/appEventType';
-import { AppLevelModel } from './models/appLevel';
-import { AppLevelGrantModel } from './models/appLevelGrant';
-import { AppLevelRequirementModel } from './models/appLevelRequirement';
 import { AppLimitCapModel } from './models/appLimitCap';
 import { AppLimitCapsDefaultModel } from './models/appLimitCapsDefault';
 import { AppLimitModel } from './models/appLimit';
@@ -16,12 +9,6 @@ import { AppLimitCreditRedemptionModel } from './models/appLimitCreditRedemption
 import { AppLimitDefaultModel } from './models/appLimitDefault';
 import { AppLimitEventModel } from './models/appLimitEvent';
 import { AppLimitWarningModel } from './models/appLimitWarning';
-import { BillingUsageSummaryModel } from './models/billingUsageSummary';
-import { LedgerModel } from './models/ledger';
-import { MeterModel } from './models/meter';
-import { MeterCreditModel } from './models/meterCredit';
-import { MeterDefaultModel } from './models/meterDefault';
-import { MeterSourceModel } from './models/meterSource';
 import { OrgLimitAggregateModel } from './models/orgLimitAggregate';
 import { OrgLimitCapModel } from './models/orgLimitCap';
 import { OrgLimitCapsDefaultModel } from './models/orgLimitCapsDefault';
@@ -30,13 +17,6 @@ import { OrgLimitCreditModel } from './models/orgLimitCredit';
 import { OrgLimitDefaultModel } from './models/orgLimitDefault';
 import { OrgLimitEventModel } from './models/orgLimitEvent';
 import { OrgLimitWarningModel } from './models/orgLimitWarning';
-import { PlanCapModel } from './models/planCap';
-import { PlanModel } from './models/plan';
-import { PlanLimitModel } from './models/planLimit';
-import { PlanMeterLimitModel } from './models/planMeterLimit';
-import { PlanOverrideModel } from './models/planOverride';
-import { PlanPricingModel } from './models/planPricing';
-import { PlanSubscriptionModel } from './models/planSubscription';
 export type { OrmClientConfig, QueryResult, GraphQLError, GraphQLAdapter } from './client';
 export { GraphQLRequestError, FetchAdapter } from './client';
 export { QueryBuilder } from './query-builder';
@@ -68,13 +48,6 @@ export { createMutationOperations } from './mutation';
  * ```
  */
 export declare function createClient(config: OrmClientConfig): {
-    appAchievementReward: AppAchievementRewardModel;
-    appEventAggregate: AppEventAggregateModel;
-    appEvent: AppEventModel;
-    appEventType: AppEventTypeModel;
-    appLevel: AppLevelModel;
-    appLevelGrant: AppLevelGrantModel;
-    appLevelRequirement: AppLevelRequirementModel;
     appLimitCap: AppLimitCapModel;
     appLimitCapsDefault: AppLimitCapsDefaultModel;
     appLimit: AppLimitModel;
@@ -85,12 +58,6 @@ export declare function createClient(config: OrmClientConfig): {
     appLimitDefault: AppLimitDefaultModel;
     appLimitEvent: AppLimitEventModel;
     appLimitWarning: AppLimitWarningModel;
-    billingUsageSummary: BillingUsageSummaryModel;
-    ledger: LedgerModel;
-    meter: MeterModel;
-    meterCredit: MeterCreditModel;
-    meterDefault: MeterDefaultModel;
-    meterSource: MeterSourceModel;
     orgLimitAggregate: OrgLimitAggregateModel;
     orgLimitCap: OrgLimitCapModel;
     orgLimitCapsDefault: OrgLimitCapsDefaultModel;
@@ -99,13 +66,6 @@ export declare function createClient(config: OrmClientConfig): {
     orgLimitDefault: OrgLimitDefaultModel;
     orgLimitEvent: OrgLimitEventModel;
     orgLimitWarning: OrgLimitWarningModel;
-    planCap: PlanCapModel;
-    plan: PlanModel;
-    planLimit: PlanLimitModel;
-    planMeterLimit: PlanMeterLimitModel;
-    planOverride: PlanOverrideModel;
-    planPricing: PlanPricingModel;
-    planSubscription: PlanSubscriptionModel;
     query: {
         captureAppLimitDefaults: (options?: {
             select?: Record<string, unknown>;
@@ -117,43 +77,13 @@ export declare function createClient(config: OrmClientConfig): {
         }) => import("./query-builder").QueryBuilder<{
             captureOrgLimitDefaults: unknown | null;
         }>;
-        captureTrustLadder: (options?: {
-            select?: Record<string, unknown>;
-        }) => import("./query-builder").QueryBuilder<{
-            captureTrustLadder: unknown | null;
-        }>;
-        eventsAchieved: (args: import("./query").EventsAchievedVariables, options?: {
-            select?: Record<string, unknown>;
-        }) => import("./query-builder").QueryBuilder<{
-            eventsAchieved: boolean | null;
-        }>;
-        eventsRequired: (args: import("./query").EventsRequiredVariables, options?: {
-            select?: Record<string, unknown>;
-        }) => import("./query-builder").QueryBuilder<{
-            eventsRequired: import("./input-types").AppLevelRequirementConnection | null;
-        }>;
     };
     mutation: {
-        grantAchievement: <S extends import("./input-types").GrantAchievementPayloadSelect>(args: import("./mutation").GrantAchievementVariables, options: {
-            select: S;
-        } & import("./select-types").StrictSelect<S, import("./input-types").GrantAchievementPayloadSelect>) => import("./query-builder").QueryBuilder<{
-            grantAchievement: import("./select-types").InferSelectResult<import("./input-types").GrantAchievementPayload, S> | null;
-        }>;
         provisionBucket: <S extends import("./input-types").ProvisionBucketPayloadSelect>(args: import("./mutation").ProvisionBucketVariables, options: {
             select: S;
         } & import("./select-types").StrictSelect<S, import("./input-types").ProvisionBucketPayloadSelect>) => import("./query-builder").QueryBuilder<{
             provisionBucket: import("./select-types").InferSelectResult<import("./input-types").ProvisionBucketPayload, S> | null;
         }>;
-        recomputeCapabilities: <S extends import("./input-types").RecomputeCapabilitiesPayloadSelect>(args: import("./mutation").RecomputeCapabilitiesVariables, options: {
-            select: S;
-        } & import("./select-types").StrictSelect<S, import("./input-types").RecomputeCapabilitiesPayloadSelect>) => import("./query-builder").QueryBuilder<{
-            recomputeCapabilities: import("./select-types").InferSelectResult<import("./input-types").RecomputeCapabilitiesPayload, S> | null;
-        }>;
-        revokeAchievement: <S extends import("./input-types").RevokeAchievementPayloadSelect>(args: import("./mutation").RevokeAchievementVariables, options: {
-            select: S;
-        } & import("./select-types").StrictSelect<S, import("./input-types").RevokeAchievementPayloadSelect>) => import("./query-builder").QueryBuilder<{
-            revokeAchievement: import("./select-types").InferSelectResult<import("./input-types").RevokeAchievementPayload, S> | null;
-        }>;
         seedAppLimitCapsDefaults: <S extends import("./input-types").SeedAppLimitCapsDefaultsPayloadSelect>(args: import("./mutation").SeedAppLimitCapsDefaultsVariables, options: {
             select: S;
         } & import("./select-types").StrictSelect<S, import("./input-types").SeedAppLimitCapsDefaultsPayloadSelect>) => import("./query-builder").QueryBuilder<{
@@ -164,11 +94,6 @@ export declare function createClient(config: OrmClientConfig): {
         } & import("./select-types").StrictSelect<S, import("./input-types").SeedAppLimitDefaultsPayloadSelect>) => import("./query-builder").QueryBuilder<{
             seedAppLimitDefaults: import("./select-types").InferSelectResult<import("./input-types").SeedAppLimitDefaultsPayload, S> | null;
         }>;
-        seedMeterDefaults: <S extends import("./input-types").SeedMeterDefaultsPayloadSelect>(args: import("./mutation").SeedMeterDefaultsVariables, options: {
-            select: S;
-        } & import("./select-types").StrictSelect<S, import("./input-types").SeedMeterDefaultsPayloadSelect>) => import("./query-builder").QueryBuilder<{
-            seedMeterDefaults: import("./select-types").InferSelectResult<import("./input-types").SeedMeterDefaultsPayload, S> | null;
-        }>;
         seedOrgLimitCapsDefaults: <S extends import("./input-types").SeedOrgLimitCapsDefaultsPayloadSelect>(args: import("./mutation").SeedOrgLimitCapsDefaultsVariables, options: {
             select: S;
         } & import("./select-types").StrictSelect<S, import("./input-types").SeedOrgLimitCapsDefaultsPayloadSelect>) => import("./query-builder").QueryBuilder<{
@@ -179,15 +104,5 @@ export declare function createClient(config: OrmClientConfig): {
         } & import("./select-types").StrictSelect<S, import("./input-types").SeedOrgLimitDefaultsPayloadSelect>) => import("./query-builder").QueryBuilder<{
             seedOrgLimitDefaults: import("./select-types").InferSelectResult<import("./input-types").SeedOrgLimitDefaultsPayload, S> | null;
         }>;
-        seedPlan: <S extends import("./input-types").SeedPlanPayloadSelect>(args: import("./mutation").SeedPlanVariables, options: {
-            select: S;
-        } & import("./select-types").StrictSelect<S, import("./input-types").SeedPlanPayloadSelect>) => import("./query-builder").QueryBuilder<{
-            seedPlan: import("./select-types").InferSelectResult<import("./input-types").SeedPlanPayload, S> | null;
-        }>;
-        seedTrustLadder: <S extends import("./input-types").SeedTrustLadderPayloadSelect>(args: import("./mutation").SeedTrustLadderVariables, options: {
-            select: S;
-        } & import("./select-types").StrictSelect<S, import("./input-types").SeedTrustLadderPayloadSelect>) => import("./query-builder").QueryBuilder<{
-            seedTrustLadder: import("./select-types").InferSelectResult<import("./input-types").SeedTrustLadderPayload, S> | null;
-        }>;
     };
 };

package/usage/orm/index.js

@@ -22,13 +22,6 @@ exports.createClient = createClient;
  * DO NOT EDIT - changes will be overwritten
  */
 const client_1 = require("./client");
-const appAchievementReward_1 = require("./models/appAchievementReward");
-const appEventAggregate_1 = require("./models/appEventAggregate");
-const appEvent_1 = require("./models/appEvent");
-const appEventType_1 = require("./models/appEventType");
-const appLevel_1 = require("./models/appLevel");
-const appLevelGrant_1 = require("./models/appLevelGrant");
-const appLevelRequirement_1 = require("./models/appLevelRequirement");
 const appLimitCap_1 = require("./models/appLimitCap");
 const appLimitCapsDefault_1 = require("./models/appLimitCapsDefault");
 const appLimit_1 = require("./models/appLimit");
@@ -39,12 +32,6 @@ const appLimitCreditRedemption_1 = require("./models/appLimitCreditRedemption");
 const appLimitDefault_1 = require("./models/appLimitDefault");
 const appLimitEvent_1 = require("./models/appLimitEvent");
 const appLimitWarning_1 = require("./models/appLimitWarning");
-const billingUsageSummary_1 = require("./models/billingUsageSummary");
-const ledger_1 = require("./models/ledger");
-const meter_1 = require("./models/meter");
-const meterCredit_1 = require("./models/meterCredit");
-const meterDefault_1 = require("./models/meterDefault");
-const meterSource_1 = require("./models/meterSource");
 const orgLimitAggregate_1 = require("./models/orgLimitAggregate");
 const orgLimitCap_1 = require("./models/orgLimitCap");
 const orgLimitCapsDefault_1 = require("./models/orgLimitCapsDefault");
@@ -53,13 +40,6 @@ const orgLimitCredit_1 = require("./models/orgLimitCredit");
 const orgLimitDefault_1 = require("./models/orgLimitDefault");
 const orgLimitEvent_1 = require("./models/orgLimitEvent");
 const orgLimitWarning_1 = require("./models/orgLimitWarning");
-const planCap_1 = require("./models/planCap");
-const plan_1 = require("./models/plan");
-const planLimit_1 = require("./models/planLimit");
-const planMeterLimit_1 = require("./models/planMeterLimit");
-const planOverride_1 = require("./models/planOverride");
-const planPricing_1 = require("./models/planPricing");
-const planSubscription_1 = require("./models/planSubscription");
 const query_1 = require("./query");
 const mutation_1 = require("./mutation");
 var client_2 = require("./client");
@@ -99,13 +79,6 @@ Object.defineProperty(exports, "createMutationOperations", { enumerable: true, g
 function createClient(config) {
     const client = new client_1.OrmClient(config);
     return {
-        appAchievementReward: new appAchievementReward_1.AppAchievementRewardModel(client),
-        appEventAggregate: new appEventAggregate_1.AppEventAggregateModel(client),
-        appEvent: new appEvent_1.AppEventModel(client),
-        appEventType: new appEventType_1.AppEventTypeModel(client),
-        appLevel: new appLevel_1.AppLevelModel(client),
-        appLevelGrant: new appLevelGrant_1.AppLevelGrantModel(client),
-        appLevelRequirement: new appLevelRequirement_1.AppLevelRequirementModel(client),
         appLimitCap: new appLimitCap_1.AppLimitCapModel(client),
         appLimitCapsDefault: new appLimitCapsDefault_1.AppLimitCapsDefaultModel(client),
         appLimit: new appLimit_1.AppLimitModel(client),
@@ -116,12 +89,6 @@ function createClient(config) {
         appLimitDefault: new appLimitDefault_1.AppLimitDefaultModel(client),
         appLimitEvent: new appLimitEvent_1.AppLimitEventModel(client),
         appLimitWarning: new appLimitWarning_1.AppLimitWarningModel(client),
-        billingUsageSummary: new billingUsageSummary_1.BillingUsageSummaryModel(client),
-        ledger: new ledger_1.LedgerModel(client),
-        meter: new meter_1.MeterModel(client),
-        meterCredit: new meterCredit_1.MeterCreditModel(client),
-        meterDefault: new meterDefault_1.MeterDefaultModel(client),
-        meterSource: new meterSource_1.MeterSourceModel(client),
         orgLimitAggregate: new orgLimitAggregate_1.OrgLimitAggregateModel(client),
         orgLimitCap: new orgLimitCap_1.OrgLimitCapModel(client),
         orgLimitCapsDefault: new orgLimitCapsDefault_1.OrgLimitCapsDefaultModel(client),
@@ -130,13 +97,6 @@ function createClient(config) {
         orgLimitDefault: new orgLimitDefault_1.OrgLimitDefaultModel(client),
         orgLimitEvent: new orgLimitEvent_1.OrgLimitEventModel(client),
         orgLimitWarning: new orgLimitWarning_1.OrgLimitWarningModel(client),
-        planCap: new planCap_1.PlanCapModel(client),
-        plan: new plan_1.PlanModel(client),
-        planLimit: new planLimit_1.PlanLimitModel(client),
-        planMeterLimit: new planMeterLimit_1.PlanMeterLimitModel(client),
-        planOverride: new planOverride_1.PlanOverrideModel(client),
-        planPricing: new planPricing_1.PlanPricingModel(client),
-        planSubscription: new planSubscription_1.PlanSubscriptionModel(client),
         query: (0, query_1.createQueryOperations)(client),
         mutation: (0, mutation_1.createMutationOperations)(client),
     };