@constructive-sdk/cli 0.2.0

package/esm/public/cli/executor.d.ts

@@ -0,0 +1,361 @@
+export declare const getStore: () => import("appstash").ConfigStore;
+export declare function getClient(contextName?: string): {
+    orgGetManagersRecord: import("..").OrgGetManagersRecordModel;
+    orgGetSubordinatesRecord: import("..").OrgGetSubordinatesRecordModel;
+    getAllRecord: import("..").GetAllRecordModel;
+    appPermission: import("..").AppPermissionModel;
+    orgPermission: import("..").OrgPermissionModel;
+    object: import("..").ObjectModel;
+    appLevelRequirement: import("..").AppLevelRequirementModel;
+    database: import("..").DatabaseModel;
+    schema: import("..").SchemaModel;
+    table: import("..").TableModel;
+    checkConstraint: import("..").CheckConstraintModel;
+    field: import("..").FieldModel;
+    foreignKeyConstraint: import("..").ForeignKeyConstraintModel;
+    fullTextSearch: import("..").FullTextSearchModel;
+    index: import("..").IndexModel;
+    policy: import("..").PolicyModel;
+    primaryKeyConstraint: import("..").PrimaryKeyConstraintModel;
+    tableGrant: import("..").TableGrantModel;
+    trigger: import("..").TriggerModel;
+    uniqueConstraint: import("..").UniqueConstraintModel;
+    view: import("..").ViewModel;
+    viewTable: import("..").ViewTableModel;
+    viewGrant: import("..").ViewGrantModel;
+    viewRule: import("..").ViewRuleModel;
+    tableModule: import("..").TableModuleModel;
+    tableTemplateModule: import("..").TableTemplateModuleModel;
+    secureTableProvision: import("..").SecureTableProvisionModel;
+    relationProvision: import("..").RelationProvisionModel;
+    schemaGrant: import("..").SchemaGrantModel;
+    defaultPrivilege: import("..").DefaultPrivilegeModel;
+    apiSchema: import("..").ApiSchemaModel;
+    apiModule: import("..").ApiModuleModel;
+    domain: import("..").DomainModel;
+    siteMetadatum: import("..").SiteMetadatumModel;
+    siteModule: import("..").SiteModuleModel;
+    siteTheme: import("..").SiteThemeModel;
+    triggerFunction: import("..").TriggerFunctionModel;
+    api: import("..").ApiModel;
+    site: import("..").SiteModel;
+    app: import("..").AppModel;
+    connectedAccountsModule: import("..").ConnectedAccountsModuleModel;
+    cryptoAddressesModule: import("..").CryptoAddressesModuleModel;
+    cryptoAuthModule: import("..").CryptoAuthModuleModel;
+    defaultIdsModule: import("..").DefaultIdsModuleModel;
+    denormalizedTableField: import("..").DenormalizedTableFieldModel;
+    emailsModule: import("..").EmailsModuleModel;
+    encryptedSecretsModule: import("..").EncryptedSecretsModuleModel;
+    fieldModule: import("..").FieldModuleModel;
+    invitesModule: import("..").InvitesModuleModel;
+    levelsModule: import("..").LevelsModuleModel;
+    limitsModule: import("..").LimitsModuleModel;
+    membershipTypesModule: import("..").MembershipTypesModuleModel;
+    membershipsModule: import("..").MembershipsModuleModel;
+    permissionsModule: import("..").PermissionsModuleModel;
+    phoneNumbersModule: import("..").PhoneNumbersModuleModel;
+    profilesModule: import("..").ProfilesModuleModel;
+    rlsModule: import("..").RlsModuleModel;
+    secretsModule: import("..").SecretsModuleModel;
+    sessionsModule: import("..").SessionsModuleModel;
+    userAuthModule: import("..").UserAuthModuleModel;
+    usersModule: import("..").UsersModuleModel;
+    uuidModule: import("..").UuidModuleModel;
+    databaseProvisionModule: import("..").DatabaseProvisionModuleModel;
+    appAdminGrant: import("..").AppAdminGrantModel;
+    appOwnerGrant: import("..").AppOwnerGrantModel;
+    appGrant: import("..").AppGrantModel;
+    orgMembership: import("..").OrgMembershipModel;
+    orgMember: import("..").OrgMemberModel;
+    orgAdminGrant: import("..").OrgAdminGrantModel;
+    orgOwnerGrant: import("..").OrgOwnerGrantModel;
+    orgGrant: import("..").OrgGrantModel;
+    orgChartEdge: import("..").OrgChartEdgeModel;
+    orgChartEdgeGrant: import("..").OrgChartEdgeGrantModel;
+    appLimit: import("..").AppLimitModel;
+    orgLimit: import("..").OrgLimitModel;
+    appStep: import("..").AppStepModel;
+    appAchievement: import("..").AppAchievementModel;
+    invite: import("..").InviteModel;
+    claimedInvite: import("..").ClaimedInviteModel;
+    orgInvite: import("..").OrgInviteModel;
+    orgClaimedInvite: import("..").OrgClaimedInviteModel;
+    ref: import("..").RefModel;
+    store: import("..").StoreModel;
+    appPermissionDefault: import("..").AppPermissionDefaultModel;
+    roleType: import("..").RoleTypeModel;
+    orgPermissionDefault: import("..").OrgPermissionDefaultModel;
+    cryptoAddress: import("..").CryptoAddressModel;
+    appLimitDefault: import("..").AppLimitDefaultModel;
+    orgLimitDefault: import("..").OrgLimitDefaultModel;
+    connectedAccount: import("..").ConnectedAccountModel;
+    phoneNumber: import("..").PhoneNumberModel;
+    membershipType: import("..").MembershipTypeModel;
+    nodeTypeRegistry: import("..").NodeTypeRegistryModel;
+    appMembershipDefault: import("..").AppMembershipDefaultModel;
+    commit: import("..").CommitModel;
+    orgMembershipDefault: import("..").OrgMembershipDefaultModel;
+    auditLog: import("..").AuditLogModel;
+    appLevel: import("..").AppLevelModel;
+    email: import("..").EmailModel;
+    sqlMigration: import("..").SqlMigrationModel;
+    astMigration: import("..").AstMigrationModel;
+    user: import("..").UserModel;
+    appMembership: import("..").AppMembershipModel;
+    hierarchyModule: import("..").HierarchyModuleModel;
+    query: {
+        currentUserId: (options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            currentUserId: string | null;
+        }>;
+        currentIpAddress: (options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            currentIpAddress: string | null;
+        }>;
+        currentUserAgent: (options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            currentUserAgent: string | null;
+        }>;
+        appPermissionsGetPaddedMask: (args: import("../orm/query").AppPermissionsGetPaddedMaskVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            appPermissionsGetPaddedMask: string | null;
+        }>;
+        orgPermissionsGetPaddedMask: (args: import("../orm/query").OrgPermissionsGetPaddedMaskVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            orgPermissionsGetPaddedMask: string | null;
+        }>;
+        stepsAchieved: (args: import("../orm/query").StepsAchievedVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            stepsAchieved: boolean | null;
+        }>;
+        revParse: (args: import("../orm/query").RevParseVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            revParse: string | null;
+        }>;
+        orgIsManagerOf: (args: import("../orm/query").OrgIsManagerOfVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            orgIsManagerOf: boolean | null;
+        }>;
+        appPermissionsGetMask: (args: import("../orm/query").AppPermissionsGetMaskVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            appPermissionsGetMask: string | null;
+        }>;
+        orgPermissionsGetMask: (args: import("../orm/query").OrgPermissionsGetMaskVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            orgPermissionsGetMask: string | null;
+        }>;
+        appPermissionsGetMaskByNames: (args: import("../orm/query").AppPermissionsGetMaskByNamesVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            appPermissionsGetMaskByNames: string | null;
+        }>;
+        orgPermissionsGetMaskByNames: (args: import("../orm/query").OrgPermissionsGetMaskByNamesVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            orgPermissionsGetMaskByNames: string | null;
+        }>;
+        appPermissionsGetByMask: (args: import("../orm/query").AppPermissionsGetByMaskVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            appPermissionsGetByMask: import("../orm/input-types").AppPermissionConnection | null;
+        }>;
+        orgPermissionsGetByMask: (args: import("../orm/query").OrgPermissionsGetByMaskVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            orgPermissionsGetByMask: import("../orm/input-types").OrgPermissionConnection | null;
+        }>;
+        getAllObjectsFromRoot: (args: import("../orm/query").GetAllObjectsFromRootVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            getAllObjectsFromRoot: import("../orm/input-types").ObjectConnection | null;
+        }>;
+        getPathObjectsFromRoot: (args: import("../orm/query").GetPathObjectsFromRootVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            getPathObjectsFromRoot: import("../orm/input-types").ObjectConnection | null;
+        }>;
+        getObjectAtPath: <S extends import("../orm/input-types").ObjectSelect>(args: import("../orm/query").GetObjectAtPathVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").ObjectSelect>) => import("..").QueryBuilder<{
+            getObjectAtPath: import("..").InferSelectResult<import("../orm/input-types").Object, S> | null;
+        }>;
+        stepsRequired: (args: import("../orm/query").StepsRequiredVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("..").QueryBuilder<{
+            stepsRequired: import("../orm/input-types").AppLevelRequirementConnection | null;
+        }>;
+        currentUser: <S extends import("../orm/input-types").UserSelect>(options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").UserSelect>) => import("..").QueryBuilder<{
+            currentUser: import("..").InferSelectResult<import("../orm/input-types").User, S> | null;
+        }>;
+    };
+    mutation: {
+        signOut: <S extends import("../orm/input-types").SignOutPayloadSelect>(args: import("../orm/mutation").SignOutVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SignOutPayloadSelect>) => import("..").QueryBuilder<{
+            signOut: import("..").InferSelectResult<import("../orm/input-types").SignOutPayload, S> | null;
+        }>;
+        sendAccountDeletionEmail: <S extends import("../orm/input-types").SendAccountDeletionEmailPayloadSelect>(args: import("../orm/mutation").SendAccountDeletionEmailVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SendAccountDeletionEmailPayloadSelect>) => import("..").QueryBuilder<{
+            sendAccountDeletionEmail: import("..").InferSelectResult<import("../orm/input-types").SendAccountDeletionEmailPayload, S> | null;
+        }>;
+        checkPassword: <S extends import("../orm/input-types").CheckPasswordPayloadSelect>(args: import("../orm/mutation").CheckPasswordVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").CheckPasswordPayloadSelect>) => import("..").QueryBuilder<{
+            checkPassword: import("..").InferSelectResult<import("../orm/input-types").CheckPasswordPayload, S> | null;
+        }>;
+        submitInviteCode: <S extends import("../orm/input-types").SubmitInviteCodePayloadSelect>(args: import("../orm/mutation").SubmitInviteCodeVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SubmitInviteCodePayloadSelect>) => import("..").QueryBuilder<{
+            submitInviteCode: import("..").InferSelectResult<import("../orm/input-types").SubmitInviteCodePayload, S> | null;
+        }>;
+        submitOrgInviteCode: <S extends import("../orm/input-types").SubmitOrgInviteCodePayloadSelect>(args: import("../orm/mutation").SubmitOrgInviteCodeVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SubmitOrgInviteCodePayloadSelect>) => import("..").QueryBuilder<{
+            submitOrgInviteCode: import("..").InferSelectResult<import("../orm/input-types").SubmitOrgInviteCodePayload, S> | null;
+        }>;
+        freezeObjects: <S extends import("../orm/input-types").FreezeObjectsPayloadSelect>(args: import("../orm/mutation").FreezeObjectsVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").FreezeObjectsPayloadSelect>) => import("..").QueryBuilder<{
+            freezeObjects: import("..").InferSelectResult<import("../orm/input-types").FreezeObjectsPayload, S> | null;
+        }>;
+        initEmptyRepo: <S extends import("../orm/input-types").InitEmptyRepoPayloadSelect>(args: import("../orm/mutation").InitEmptyRepoVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").InitEmptyRepoPayloadSelect>) => import("..").QueryBuilder<{
+            initEmptyRepo: import("..").InferSelectResult<import("../orm/input-types").InitEmptyRepoPayload, S> | null;
+        }>;
+        confirmDeleteAccount: <S extends import("../orm/input-types").ConfirmDeleteAccountPayloadSelect>(args: import("../orm/mutation").ConfirmDeleteAccountVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").ConfirmDeleteAccountPayloadSelect>) => import("..").QueryBuilder<{
+            confirmDeleteAccount: import("..").InferSelectResult<import("../orm/input-types").ConfirmDeleteAccountPayload, S> | null;
+        }>;
+        setPassword: <S extends import("../orm/input-types").SetPasswordPayloadSelect>(args: import("../orm/mutation").SetPasswordVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SetPasswordPayloadSelect>) => import("..").QueryBuilder<{
+            setPassword: import("..").InferSelectResult<import("../orm/input-types").SetPasswordPayload, S> | null;
+        }>;
+        verifyEmail: <S extends import("../orm/input-types").VerifyEmailPayloadSelect>(args: import("../orm/mutation").VerifyEmailVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").VerifyEmailPayloadSelect>) => import("..").QueryBuilder<{
+            verifyEmail: import("..").InferSelectResult<import("../orm/input-types").VerifyEmailPayload, S> | null;
+        }>;
+        resetPassword: <S extends import("../orm/input-types").ResetPasswordPayloadSelect>(args: import("../orm/mutation").ResetPasswordVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").ResetPasswordPayloadSelect>) => import("..").QueryBuilder<{
+            resetPassword: import("..").InferSelectResult<import("../orm/input-types").ResetPasswordPayload, S> | null;
+        }>;
+        removeNodeAtPath: <S extends import("../orm/input-types").RemoveNodeAtPathPayloadSelect>(args: import("../orm/mutation").RemoveNodeAtPathVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").RemoveNodeAtPathPayloadSelect>) => import("..").QueryBuilder<{
+            removeNodeAtPath: import("..").InferSelectResult<import("../orm/input-types").RemoveNodeAtPathPayload, S> | null;
+        }>;
+        bootstrapUser: <S extends import("../orm/input-types").BootstrapUserPayloadSelect>(args: import("../orm/mutation").BootstrapUserVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").BootstrapUserPayloadSelect>) => import("..").QueryBuilder<{
+            bootstrapUser: import("..").InferSelectResult<import("../orm/input-types").BootstrapUserPayload, S> | null;
+        }>;
+        setDataAtPath: <S extends import("../orm/input-types").SetDataAtPathPayloadSelect>(args: import("../orm/mutation").SetDataAtPathVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SetDataAtPathPayloadSelect>) => import("..").QueryBuilder<{
+            setDataAtPath: import("..").InferSelectResult<import("../orm/input-types").SetDataAtPathPayload, S> | null;
+        }>;
+        setPropsAndCommit: <S extends import("../orm/input-types").SetPropsAndCommitPayloadSelect>(args: import("../orm/mutation").SetPropsAndCommitVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SetPropsAndCommitPayloadSelect>) => import("..").QueryBuilder<{
+            setPropsAndCommit: import("..").InferSelectResult<import("../orm/input-types").SetPropsAndCommitPayload, S> | null;
+        }>;
+        provisionDatabaseWithUser: <S extends import("../orm/input-types").ProvisionDatabaseWithUserPayloadSelect>(args: import("../orm/mutation").ProvisionDatabaseWithUserVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").ProvisionDatabaseWithUserPayloadSelect>) => import("..").QueryBuilder<{
+            provisionDatabaseWithUser: import("..").InferSelectResult<import("../orm/input-types").ProvisionDatabaseWithUserPayload, S> | null;
+        }>;
+        signInOneTimeToken: <S extends import("../orm/input-types").SignInOneTimeTokenPayloadSelect>(args: import("../orm/mutation").SignInOneTimeTokenVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SignInOneTimeTokenPayloadSelect>) => import("..").QueryBuilder<{
+            signInOneTimeToken: import("..").InferSelectResult<import("../orm/input-types").SignInOneTimeTokenPayload, S> | null;
+        }>;
+        createUserDatabase: <S extends import("../orm/input-types").CreateUserDatabasePayloadSelect>(args: import("../orm/mutation").CreateUserDatabaseVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").CreateUserDatabasePayloadSelect>) => import("..").QueryBuilder<{
+            createUserDatabase: import("..").InferSelectResult<import("../orm/input-types").CreateUserDatabasePayload, S> | null;
+        }>;
+        extendTokenExpires: <S extends import("../orm/input-types").ExtendTokenExpiresPayloadSelect>(args: import("../orm/mutation").ExtendTokenExpiresVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").ExtendTokenExpiresPayloadSelect>) => import("..").QueryBuilder<{
+            extendTokenExpires: import("..").InferSelectResult<import("../orm/input-types").ExtendTokenExpiresPayload, S> | null;
+        }>;
+        signIn: <S extends import("../orm/input-types").SignInPayloadSelect>(args: import("../orm/mutation").SignInVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SignInPayloadSelect>) => import("..").QueryBuilder<{
+            signIn: import("..").InferSelectResult<import("../orm/input-types").SignInPayload, S> | null;
+        }>;
+        signUp: <S extends import("../orm/input-types").SignUpPayloadSelect>(args: import("../orm/mutation").SignUpVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SignUpPayloadSelect>) => import("..").QueryBuilder<{
+            signUp: import("..").InferSelectResult<import("../orm/input-types").SignUpPayload, S> | null;
+        }>;
+        setFieldOrder: <S extends import("../orm/input-types").SetFieldOrderPayloadSelect>(args: import("../orm/mutation").SetFieldOrderVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SetFieldOrderPayloadSelect>) => import("..").QueryBuilder<{
+            setFieldOrder: import("..").InferSelectResult<import("../orm/input-types").SetFieldOrderPayload, S> | null;
+        }>;
+        oneTimeToken: <S extends import("../orm/input-types").OneTimeTokenPayloadSelect>(args: import("../orm/mutation").OneTimeTokenVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").OneTimeTokenPayloadSelect>) => import("..").QueryBuilder<{
+            oneTimeToken: import("..").InferSelectResult<import("../orm/input-types").OneTimeTokenPayload, S> | null;
+        }>;
+        insertNodeAtPath: <S extends import("../orm/input-types").InsertNodeAtPathPayloadSelect>(args: import("../orm/mutation").InsertNodeAtPathVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").InsertNodeAtPathPayloadSelect>) => import("..").QueryBuilder<{
+            insertNodeAtPath: import("..").InferSelectResult<import("../orm/input-types").InsertNodeAtPathPayload, S> | null;
+        }>;
+        updateNodeAtPath: <S extends import("../orm/input-types").UpdateNodeAtPathPayloadSelect>(args: import("../orm/mutation").UpdateNodeAtPathVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").UpdateNodeAtPathPayloadSelect>) => import("..").QueryBuilder<{
+            updateNodeAtPath: import("..").InferSelectResult<import("../orm/input-types").UpdateNodeAtPathPayload, S> | null;
+        }>;
+        setAndCommit: <S extends import("../orm/input-types").SetAndCommitPayloadSelect>(args: import("../orm/mutation").SetAndCommitVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SetAndCommitPayloadSelect>) => import("..").QueryBuilder<{
+            setAndCommit: import("..").InferSelectResult<import("../orm/input-types").SetAndCommitPayload, S> | null;
+        }>;
+        applyRls: <S extends import("../orm/input-types").ApplyRlsPayloadSelect>(args: import("../orm/mutation").ApplyRlsVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").ApplyRlsPayloadSelect>) => import("..").QueryBuilder<{
+            applyRls: import("..").InferSelectResult<import("../orm/input-types").ApplyRlsPayload, S> | null;
+        }>;
+        forgotPassword: <S extends import("../orm/input-types").ForgotPasswordPayloadSelect>(args: import("../orm/mutation").ForgotPasswordVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").ForgotPasswordPayloadSelect>) => import("..").QueryBuilder<{
+            forgotPassword: import("..").InferSelectResult<import("../orm/input-types").ForgotPasswordPayload, S> | null;
+        }>;
+        sendVerificationEmail: <S extends import("../orm/input-types").SendVerificationEmailPayloadSelect>(args: import("../orm/mutation").SendVerificationEmailVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").SendVerificationEmailPayloadSelect>) => import("..").QueryBuilder<{
+            sendVerificationEmail: import("..").InferSelectResult<import("../orm/input-types").SendVerificationEmailPayload, S> | null;
+        }>;
+        verifyPassword: <S extends import("../orm/input-types").VerifyPasswordPayloadSelect>(args: import("../orm/mutation").VerifyPasswordVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").VerifyPasswordPayloadSelect>) => import("..").QueryBuilder<{
+            verifyPassword: import("..").InferSelectResult<import("../orm/input-types").VerifyPasswordPayload, S> | null;
+        }>;
+        verifyTotp: <S extends import("../orm/input-types").VerifyTotpPayloadSelect>(args: import("../orm/mutation").VerifyTotpVariables, options: {
+            select: S;
+        } & import("..").StrictSelect<S, import("../orm/input-types").VerifyTotpPayloadSelect>) => import("..").QueryBuilder<{
+            verifyTotp: import("..").InferSelectResult<import("../orm/input-types").VerifyTotpPayload, S> | null;
+        }>;
+    };
+};

package/esm/public/cli/executor.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+/**
+ * Executor and config store for CLI
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { NodeHttpAdapter } from './node-fetch';
+import { createConfigStore } from 'appstash';
+import { createClient } from '../orm';
+const store = createConfigStore('csdk');
+export const getStore = () => store;
+export function getClient(contextName) {
+    let ctx = null;
+    if (contextName) {
+        ctx = store.loadContext(contextName);
+        if (!ctx) {
+            throw new Error(`Context "${contextName}" not found.`);
+        }
+    }
+    else {
+        ctx = store.getCurrentContext();
+        if (!ctx) {
+            throw new Error('No active context. Run "context create" or "context use" first.');
+        }
+    }
+    const headers = {};
+    if (store.hasValidCredentials(ctx.name)) {
+        const creds = store.getCredentials(ctx.name);
+        if (creds?.token) {
+            headers.Authorization = `Bearer ${creds.token}`;
+        }
+    }
+    return createClient({
+        adapter: new NodeHttpAdapter(ctx.endpoint, headers),
+    });
+}

package/esm/public/cli/index.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/public/cli/index.js

@@ -0,0 +1,25 @@
+// @ts-nocheck
+/**
+ * CLI entry point
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { CLI, getPackageJson } from 'inquirerer';
+import { commands } from './commands';
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+    const pkg = getPackageJson(__dirname);
+    console.log(pkg.version);
+    process.exit(0);
+}
+// Check for --tty false to enable non-interactive mode (noTty)
+const ttyIdx = process.argv.indexOf('--tty');
+const noTty = ttyIdx !== -1 && process.argv[ttyIdx + 1] === 'false';
+const options = {
+    noTty,
+    minimistOpts: { alias: { v: 'version', h: 'help' } },
+};
+const app = new CLI(commands, options);
+app.run().catch((e) => {
+    console.error('Unexpected error:', e);
+    process.exit(1);
+});

package/esm/public/cli/node-fetch.d.ts

@@ -0,0 +1,26 @@
+import type { GraphQLAdapter, QueryResult } from '@constructive-io/graphql-types';
+/**
+ * Options for individual execute calls.
+ * Allows per-request header overrides and request cancellation.
+ */
+export interface NodeHttpExecuteOptions {
+    /** Additional headers to include in this request only */
+    headers?: Record<string, string>;
+    /** AbortSignal for request cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * GraphQL adapter that uses node:http/node:https for requests.
+ *
+ * Handles *.localhost subdomains by rewriting the hostname to "localhost"
+ * and injecting the original Host header for server-side subdomain routing.
+ */
+export declare class NodeHttpAdapter implements GraphQLAdapter {
+    private endpoint;
+    private headers;
+    private url;
+    constructor(endpoint: string, headers?: Record<string, string>);
+    execute<T>(document: string, variables?: Record<string, unknown>, options?: NodeHttpExecuteOptions): Promise<QueryResult<T>>;
+    setHeaders(headers: Record<string, string>): void;
+    getEndpoint(): string;
+}

package/esm/public/cli/node-fetch.js

@@ -0,0 +1,123 @@
+// @ts-nocheck
+/**
+ * Node HTTP adapter for localhost subdomain routing
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import http from 'node:http';
+import https from 'node:https';
+/**
+ * Check if a hostname is a localhost subdomain that needs special handling.
+ * Returns true for *.localhost (e.g. auth.localhost) but not bare "localhost".
+ */
+function isLocalhostSubdomain(hostname) {
+    return hostname.endsWith('.localhost') && hostname !== 'localhost';
+}
+/**
+ * Make an HTTP/HTTPS request using native Node modules.
+ * Supports optional AbortSignal for request cancellation.
+ */
+function makeRequest(url, options, body, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error('The operation was aborted'));
+            return;
+        }
+        const protocol = url.protocol === 'https:' ? https : http;
+        const req = protocol.request(url, options, (res) => {
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                resolve({
+                    statusCode: res.statusCode || 0,
+                    statusMessage: res.statusMessage || '',
+                    data,
+                });
+            });
+        });
+        req.on('error', reject);
+        if (signal) {
+            const onAbort = () => {
+                req.destroy(new Error('The operation was aborted'));
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            req.on('close', () => {
+                signal.removeEventListener('abort', onAbort);
+            });
+        }
+        req.write(body);
+        req.end();
+    });
+}
+/**
+ * GraphQL adapter that uses node:http/node:https for requests.
+ *
+ * Handles *.localhost subdomains by rewriting the hostname to "localhost"
+ * and injecting the original Host header for server-side subdomain routing.
+ */
+export class NodeHttpAdapter {
+    endpoint;
+    headers;
+    url;
+    constructor(endpoint, headers) {
+        this.endpoint = endpoint;
+        this.headers = headers ?? {};
+        this.url = new URL(endpoint);
+    }
+    async execute(document, variables, options) {
+        const requestUrl = new URL(this.url.href);
+        const requestHeaders = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            ...this.headers,
+            ...options?.headers,
+        };
+        // For *.localhost subdomains, rewrite hostname and inject Host header
+        if (isLocalhostSubdomain(requestUrl.hostname)) {
+            requestHeaders['Host'] = requestUrl.host;
+            requestUrl.hostname = 'localhost';
+        }
+        const body = JSON.stringify({
+            query: document,
+            variables: variables ?? {},
+        });
+        const requestOptions = {
+            method: 'POST',
+            headers: requestHeaders,
+        };
+        const response = await makeRequest(requestUrl, requestOptions, body, options?.signal);
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+            return {
+                ok: false,
+                data: null,
+                errors: [
+                    {
+                        message: `HTTP ${response.statusCode}: ${response.statusMessage}`,
+                    },
+                ],
+            };
+        }
+        const json = JSON.parse(response.data);
+        if (json.errors && json.errors.length > 0) {
+            return {
+                ok: false,
+                data: null,
+                errors: json.errors,
+            };
+        }
+        return {
+            ok: true,
+            data: json.data,
+            errors: undefined,
+        };
+    }
+    setHeaders(headers) {
+        this.headers = { ...this.headers, ...headers };
+    }
+    getEndpoint() {
+        return this.endpoint;
+    }
+}

package/esm/public/cli/utils.d.ts

@@ -0,0 +1,37 @@
+export type FieldType = 'string' | 'boolean' | 'int' | 'float' | 'json' | 'uuid' | 'enum';
+export interface FieldSchema {
+    [fieldName: string]: FieldType;
+}
+/**
+ * Coerce CLI string arguments to their proper GraphQL types based on a field schema.
+ * CLI args always arrive as strings from minimist, but GraphQL expects
+ * Boolean, Int, Float, JSON, etc.
+ */
+export declare function coerceAnswers(answers: Record<string, unknown>, schema: FieldSchema): Record<string, unknown>;
+/**
+ * Strip undefined values and filter to only schema-defined keys.
+ * This removes extra fields injected by minimist (like _, tty, etc.)
+ * and any fields that were coerced to undefined.
+ */
+export declare function stripUndefined(obj: Record<string, unknown>, schema?: FieldSchema): Record<string, unknown>;
+/**
+ * Parse mutation input from CLI.
+ * Custom mutation commands receive an `input` field as a JSON string
+ * from the CLI prompt. This parses it into a proper object.
+ */
+export declare function parseMutationInput(answers: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build a select object from a comma-separated list of dot-notation paths.
+ * Uses `nested-obj` to parse paths like 'clientMutationId,result.accessToken,result.userId'
+ * into the nested structure expected by the ORM:
+ *
+ *   { clientMutationId: true, result: { select: { accessToken: true, userId: true } } }
+ *
+ * Paths without dots set the key to `true` (scalar select).
+ * Paths with dots create nested `{ select: { ... } }` wrappers, matching the
+ * ORM's expected structure for OBJECT sub-fields (e.g. `SignUpPayloadSelect.result`).
+ *
+ * @param paths - Comma-separated dot-notation field paths (e.g. 'clientMutationId,result.accessToken')
+ * @returns The nested select object for the ORM
+ */
+export declare function buildSelectFromPaths(paths: string): Record<string, unknown>;