@constructive-io/sdk 0.0.2

package/public/orm/input-types.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionFieldsMap = void 0;
+// ============ Connection Fields Map ============
+exports.connectionFieldsMap = {
+    Database: {
+        schemas: 'Schema',
+        tables: 'Table',
+        checkConstraints: 'CheckConstraint',
+        fields: 'Field',
+        foreignKeyConstraints: 'ForeignKeyConstraint',
+        fullTextSearches: 'FullTextSearch',
+        indices: 'Index',
+        limitFunctions: 'LimitFunction',
+        policies: 'Policy',
+        primaryKeyConstraints: 'PrimaryKeyConstraint',
+        procedures: 'Procedure',
+        schemaGrants: 'SchemaGrant',
+        tableGrants: 'TableGrant',
+        triggerFunctions: 'TriggerFunction',
+        triggers: 'Trigger',
+        uniqueConstraints: 'UniqueConstraint',
+        views: 'View',
+        viewGrants: 'ViewGrant',
+        viewRules: 'ViewRule',
+        apis: 'Api',
+        apiModules: 'ApiModule',
+        apiSchemas: 'ApiSchema',
+        sites: 'Site',
+        apps: 'App',
+        domains: 'Domain',
+        siteMetadata: 'SiteMetadatum',
+        siteModules: 'SiteModule',
+        siteThemes: 'SiteTheme',
+        connectedAccountsModules: 'ConnectedAccountsModule',
+        cryptoAddressesModules: 'CryptoAddressesModule',
+        cryptoAuthModules: 'CryptoAuthModule',
+        defaultIdsModules: 'DefaultIdsModule',
+        denormalizedTableFields: 'DenormalizedTableField',
+        emailsModules: 'EmailsModule',
+        encryptedSecretsModules: 'EncryptedSecretsModule',
+        fieldModules: 'FieldModule',
+        tableModules: 'TableModule',
+        invitesModules: 'InvitesModule',
+        levelsModules: 'LevelsModule',
+        limitsModules: 'LimitsModule',
+        membershipTypesModules: 'MembershipTypesModule',
+        membershipsModules: 'MembershipsModule',
+        permissionsModules: 'PermissionsModule',
+        phoneNumbersModules: 'PhoneNumbersModule',
+        profilesModules: 'ProfilesModule',
+        rlsModules: 'RlsModule',
+        secretsModules: 'SecretsModule',
+        sessionsModules: 'SessionsModule',
+        userAuthModules: 'UserAuthModule',
+        usersModules: 'UsersModule',
+        uuidModules: 'UuidModule',
+        tableTemplateModules: 'TableTemplateModule',
+        databaseProvisionModules: 'DatabaseProvisionModule',
+    },
+    Schema: {
+        tables: 'Table',
+        schemaGrants: 'SchemaGrant',
+        views: 'View',
+        apiSchemas: 'ApiSchema',
+        tableTemplateModulesByPrivateSchemaId: 'TableTemplateModule',
+        tableTemplateModules: 'TableTemplateModule',
+    },
+    Table: {
+        checkConstraints: 'CheckConstraint',
+        fields: 'Field',
+        foreignKeyConstraints: 'ForeignKeyConstraint',
+        fullTextSearches: 'FullTextSearch',
+        indices: 'Index',
+        limitFunctions: 'LimitFunction',
+        policies: 'Policy',
+        primaryKeyConstraints: 'PrimaryKeyConstraint',
+        tableGrants: 'TableGrant',
+        triggers: 'Trigger',
+        uniqueConstraints: 'UniqueConstraint',
+        views: 'View',
+        viewTables: 'ViewTable',
+        tableModules: 'TableModule',
+        tableTemplateModulesByOwnerTableId: 'TableTemplateModule',
+        tableTemplateModules: 'TableTemplateModule',
+    },
+    View: {
+        viewTables: 'ViewTable',
+        viewGrants: 'ViewGrant',
+        viewRules: 'ViewRule',
+    },
+    Api: {
+        apiModules: 'ApiModule',
+        apiSchemas: 'ApiSchema',
+        domains: 'Domain',
+    },
+    Site: {
+        domains: 'Domain',
+        siteMetadata: 'SiteMetadatum',
+        siteModules: 'SiteModule',
+        siteThemes: 'SiteTheme',
+    },
+    User: {
+        ownedDatabases: 'Database',
+        appAdminGrantsByGrantorId: 'AppAdminGrant',
+        appOwnerGrantsByGrantorId: 'AppOwnerGrant',
+        appGrantsByGrantorId: 'AppGrant',
+        orgMembershipsByActorId: 'OrgMembership',
+        orgMembershipsByEntityId: 'OrgMembership',
+        orgMembersByActorId: 'OrgMember',
+        orgMembersByEntityId: 'OrgMember',
+        orgAdminGrantsByEntityId: 'OrgAdminGrant',
+        orgAdminGrantsByGrantorId: 'OrgAdminGrant',
+        orgOwnerGrantsByEntityId: 'OrgOwnerGrant',
+        orgOwnerGrantsByGrantorId: 'OrgOwnerGrant',
+        orgGrantsByEntityId: 'OrgGrant',
+        orgGrantsByGrantorId: 'OrgGrant',
+        appLimitsByActorId: 'AppLimit',
+        orgLimitsByActorId: 'OrgLimit',
+        orgLimitsByEntityId: 'OrgLimit',
+        appStepsByActorId: 'AppStep',
+        appAchievementsByActorId: 'AppAchievement',
+        invitesBySenderId: 'Invite',
+        claimedInvitesByReceiverId: 'ClaimedInvite',
+        claimedInvitesBySenderId: 'ClaimedInvite',
+        orgInvitesByEntityId: 'OrgInvite',
+        orgInvitesBySenderId: 'OrgInvite',
+        orgClaimedInvitesByReceiverId: 'OrgClaimedInvite',
+        orgClaimedInvitesBySenderId: 'OrgClaimedInvite',
+    },
+};

package/public/orm/models/api.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Api model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { ApiWithRelations, ApiSelect, ApiFilter, ApiOrderBy, CreateApiInput, ApiPatch } from '../input-types';
+export declare class ApiModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends ApiSelect>(args: FindManyArgs<S, ApiFilter, ApiOrderBy> & {
+        select: S;
+    } & StrictSelect<S, ApiSelect>): QueryBuilder<{
+        apis: ConnectionResult<InferSelectResult<ApiWithRelations, S>>;
+    }>;
+    findFirst<S extends ApiSelect>(args: FindFirstArgs<S, ApiFilter> & {
+        select: S;
+    } & StrictSelect<S, ApiSelect>): QueryBuilder<{
+        apis: {
+            nodes: InferSelectResult<ApiWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends ApiSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, ApiSelect>): QueryBuilder<{
+        api: InferSelectResult<ApiWithRelations, S> | null;
+    }>;
+    create<S extends ApiSelect>(args: CreateArgs<S, CreateApiInput['api']> & {
+        select: S;
+    } & StrictSelect<S, ApiSelect>): QueryBuilder<{
+        createApi: {
+            api: InferSelectResult<ApiWithRelations, S>;
+        };
+    }>;
+    update<S extends ApiSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, ApiPatch> & {
+        select: S;
+    } & StrictSelect<S, ApiSelect>): QueryBuilder<{
+        updateApi: {
+            api: InferSelectResult<ApiWithRelations, S>;
+        };
+    }>;
+    delete<S extends ApiSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, ApiSelect>): QueryBuilder<{
+        deleteApi: {
+            api: InferSelectResult<ApiWithRelations, S>;
+        };
+    }>;
+}

package/public/orm/models/api.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiModel = void 0;
+const query_builder_1 = require("../query-builder");
+const input_types_1 = require("../input-types");
+class ApiModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('Api', 'apis', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'ApiFilter', 'ApiOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'Api',
+            fieldName: 'apis',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('Api', 'apis', args.select, {
+            where: args?.where,
+        }, 'ApiFilter', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'Api',
+            fieldName: 'apis',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('Api', 'apis', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'ApiFilter', 'ApiOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'Api',
+            fieldName: 'api',
+            document,
+            variables,
+            transform: (data) => ({
+                api: data.apis?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = (0, query_builder_1.buildCreateDocument)('Api', 'createApi', 'api', args.select, args.data, 'CreateApiInput', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'Api',
+            fieldName: 'createApi',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = (0, query_builder_1.buildUpdateByPkDocument)('Api', 'updateApi', 'api', args.select, args.where.id, args.data, 'UpdateApiInput', 'id', 'apiPatch', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'Api',
+            fieldName: 'updateApi',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = (0, query_builder_1.buildDeleteByPkDocument)('Api', 'deleteApi', 'api', args.where.id, 'DeleteApiInput', 'id', args.select, input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'Api',
+            fieldName: 'deleteApi',
+            document,
+            variables,
+        });
+    }
+}
+exports.ApiModel = ApiModel;

package/public/orm/models/apiModule.d.ts

@@ -0,0 +1,56 @@
+/**
+ * ApiModule model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { ApiModuleWithRelations, ApiModuleSelect, ApiModuleFilter, ApiModuleOrderBy, CreateApiModuleInput, ApiModulePatch } from '../input-types';
+export declare class ApiModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends ApiModuleSelect>(args: FindManyArgs<S, ApiModuleFilter, ApiModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
+        apiModules: ConnectionResult<InferSelectResult<ApiModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends ApiModuleSelect>(args: FindFirstArgs<S, ApiModuleFilter> & {
+        select: S;
+    } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
+        apiModules: {
+            nodes: InferSelectResult<ApiModuleWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends ApiModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
+        apiModule: InferSelectResult<ApiModuleWithRelations, S> | null;
+    }>;
+    create<S extends ApiModuleSelect>(args: CreateArgs<S, CreateApiModuleInput['apiModule']> & {
+        select: S;
+    } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
+        createApiModule: {
+            apiModule: InferSelectResult<ApiModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends ApiModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, ApiModulePatch> & {
+        select: S;
+    } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
+        updateApiModule: {
+            apiModule: InferSelectResult<ApiModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends ApiModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, ApiModuleSelect>): QueryBuilder<{
+        deleteApiModule: {
+            apiModule: InferSelectResult<ApiModuleWithRelations, S>;
+        };
+    }>;
+}

package/public/orm/models/apiModule.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiModuleModel = void 0;
+const query_builder_1 = require("../query-builder");
+const input_types_1 = require("../input-types");
+class ApiModuleModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('ApiModule', 'apiModules', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'ApiModuleFilter', 'ApiModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ApiModule',
+            fieldName: 'apiModules',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('ApiModule', 'apiModules', args.select, {
+            where: args?.where,
+        }, 'ApiModuleFilter', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ApiModule',
+            fieldName: 'apiModules',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('ApiModule', 'apiModules', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'ApiModuleFilter', 'ApiModuleOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ApiModule',
+            fieldName: 'apiModule',
+            document,
+            variables,
+            transform: (data) => ({
+                apiModule: data.apiModules?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = (0, query_builder_1.buildCreateDocument)('ApiModule', 'createApiModule', 'apiModule', args.select, args.data, 'CreateApiModuleInput', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ApiModule',
+            fieldName: 'createApiModule',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = (0, query_builder_1.buildUpdateByPkDocument)('ApiModule', 'updateApiModule', 'apiModule', args.select, args.where.id, args.data, 'UpdateApiModuleInput', 'id', 'apiModulePatch', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ApiModule',
+            fieldName: 'updateApiModule',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = (0, query_builder_1.buildDeleteByPkDocument)('ApiModule', 'deleteApiModule', 'apiModule', args.where.id, 'DeleteApiModuleInput', 'id', args.select, input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ApiModule',
+            fieldName: 'deleteApiModule',
+            document,
+            variables,
+        });
+    }
+}
+exports.ApiModuleModel = ApiModuleModel;

package/public/orm/models/apiSchema.d.ts

@@ -0,0 +1,56 @@
+/**
+ * ApiSchema model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { ApiSchemaWithRelations, ApiSchemaSelect, ApiSchemaFilter, ApiSchemaOrderBy, CreateApiSchemaInput, ApiSchemaPatch } from '../input-types';
+export declare class ApiSchemaModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends ApiSchemaSelect>(args: FindManyArgs<S, ApiSchemaFilter, ApiSchemaOrderBy> & {
+        select: S;
+    } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
+        apiSchemas: ConnectionResult<InferSelectResult<ApiSchemaWithRelations, S>>;
+    }>;
+    findFirst<S extends ApiSchemaSelect>(args: FindFirstArgs<S, ApiSchemaFilter> & {
+        select: S;
+    } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
+        apiSchemas: {
+            nodes: InferSelectResult<ApiSchemaWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends ApiSchemaSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
+        apiSchema: InferSelectResult<ApiSchemaWithRelations, S> | null;
+    }>;
+    create<S extends ApiSchemaSelect>(args: CreateArgs<S, CreateApiSchemaInput['apiSchema']> & {
+        select: S;
+    } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
+        createApiSchema: {
+            apiSchema: InferSelectResult<ApiSchemaWithRelations, S>;
+        };
+    }>;
+    update<S extends ApiSchemaSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, ApiSchemaPatch> & {
+        select: S;
+    } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
+        updateApiSchema: {
+            apiSchema: InferSelectResult<ApiSchemaWithRelations, S>;
+        };
+    }>;
+    delete<S extends ApiSchemaSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, ApiSchemaSelect>): QueryBuilder<{
+        deleteApiSchema: {
+            apiSchema: InferSelectResult<ApiSchemaWithRelations, S>;
+        };
+    }>;
+}

package/public/orm/models/apiSchema.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSchemaModel = void 0;
+const query_builder_1 = require("../query-builder");
+const input_types_1 = require("../input-types");
+class ApiSchemaModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('ApiSchema', 'apiSchemas', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'ApiSchemaFilter', 'ApiSchemaOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ApiSchema',
+            fieldName: 'apiSchemas',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = (0, query_builder_1.buildFindFirstDocument)('ApiSchema', 'apiSchemas', args.select, {
+            where: args?.where,
+        }, 'ApiSchemaFilter', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ApiSchema',
+            fieldName: 'apiSchemas',
+            document,
+            variables,
+        });
+    }
+    findOne(args) {
+        const { document, variables } = (0, query_builder_1.buildFindManyDocument)('ApiSchema', 'apiSchemas', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'ApiSchemaFilter', 'ApiSchemaOrderBy', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'ApiSchema',
+            fieldName: 'apiSchema',
+            document,
+            variables,
+            transform: (data) => ({
+                apiSchema: data.apiSchemas?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = (0, query_builder_1.buildCreateDocument)('ApiSchema', 'createApiSchema', 'apiSchema', args.select, args.data, 'CreateApiSchemaInput', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ApiSchema',
+            fieldName: 'createApiSchema',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = (0, query_builder_1.buildUpdateByPkDocument)('ApiSchema', 'updateApiSchema', 'apiSchema', args.select, args.where.id, args.data, 'UpdateApiSchemaInput', 'id', 'apiSchemaPatch', input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ApiSchema',
+            fieldName: 'updateApiSchema',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = (0, query_builder_1.buildDeleteByPkDocument)('ApiSchema', 'deleteApiSchema', 'apiSchema', args.where.id, 'DeleteApiSchemaInput', 'id', args.select, input_types_1.connectionFieldsMap);
+        return new query_builder_1.QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'ApiSchema',
+            fieldName: 'deleteApiSchema',
+            document,
+            variables,
+        });
+    }
+}
+exports.ApiSchemaModel = ApiSchemaModel;

package/public/orm/models/app.d.ts

@@ -0,0 +1,56 @@
+/**
+ * App model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { AppWithRelations, AppSelect, AppFilter, AppOrderBy, CreateAppInput, AppPatch } from '../input-types';
+export declare class AppModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends AppSelect>(args: FindManyArgs<S, AppFilter, AppOrderBy> & {
+        select: S;
+    } & StrictSelect<S, AppSelect>): QueryBuilder<{
+        apps: ConnectionResult<InferSelectResult<AppWithRelations, S>>;
+    }>;
+    findFirst<S extends AppSelect>(args: FindFirstArgs<S, AppFilter> & {
+        select: S;
+    } & StrictSelect<S, AppSelect>): QueryBuilder<{
+        apps: {
+            nodes: InferSelectResult<AppWithRelations, S>[];
+        };
+    }>;
+    findOne<S extends AppSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, AppSelect>): QueryBuilder<{
+        app: InferSelectResult<AppWithRelations, S> | null;
+    }>;
+    create<S extends AppSelect>(args: CreateArgs<S, CreateAppInput['app']> & {
+        select: S;
+    } & StrictSelect<S, AppSelect>): QueryBuilder<{
+        createApp: {
+            app: InferSelectResult<AppWithRelations, S>;
+        };
+    }>;
+    update<S extends AppSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, AppPatch> & {
+        select: S;
+    } & StrictSelect<S, AppSelect>): QueryBuilder<{
+        updateApp: {
+            app: InferSelectResult<AppWithRelations, S>;
+        };
+    }>;
+    delete<S extends AppSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, AppSelect>): QueryBuilder<{
+        deleteApp: {
+            app: InferSelectResult<AppWithRelations, S>;
+        };
+    }>;
+}