@baseworks/account 0.2.0

package/dist/cli.d.ts

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import { ApiClient } from '@baseworks/cli/client';
+import { ContextManager } from '@baseworks/cli/context';
+
+interface LoginResult {
+    token: string;
+    user: {
+        id: string;
+        email: string;
+        name: string | null;
+    } | null;
+    role: string | null;
+    org: {
+        slug: string;
+        id: string;
+    };
+    workspace: {
+        slug: string;
+        id: string;
+    };
+    project: {
+        slug: string;
+        id: string;
+    };
+    env: {
+        slug: string;
+        id: string;
+    };
+}
+interface AccountCliDeps {
+    http: ApiClient;
+    ctx: ContextManager<Record<string, string | undefined>>;
+    appBase: string;
+    apiBase: string;
+    cliName?: string;
+    onLoginSuccess: (result: LoginResult) => void;
+}
+declare function buildLoginCommand(deps: AccountCliDeps): Command;
+declare function buildLogoutCommand(deps: AccountCliDeps): Command;
+declare function buildWhoamiCommand(deps: AccountCliDeps): Command;
+declare function buildMeCommand(deps: AccountCliDeps): Command;
+declare function buildMembersCommand(deps: AccountCliDeps): Command;
+declare function buildTokensCommand(deps: AccountCliDeps): Command;
+declare function buildAccountCommand(deps: AccountCliDeps): Command;
+
+export { type AccountCliDeps, type LoginResult, buildAccountCommand as accountCommand, buildAccountCommand, buildLoginCommand, buildLogoutCommand, buildMeCommand, buildMembersCommand, buildTokensCommand, buildWhoamiCommand };

package/dist/cli.js

@@ -0,0 +1,268 @@
+// src/cli.ts
+import { Command } from "commander";
+import { clr, kv, table, success, warn, fatal, printOutput, outputOption } from "@baseworks/cli/display";
+import { fmtDate } from "@baseworks/cli/fmt";
+function buildLoginCommand(deps) {
+  const base = deps.apiBase.replace(/\/+$/, "");
+  const cmd = new Command("login").description("Log in via browser (OIDC)");
+  cmd.addCommand(
+    new Command("browser").description("Open browser for OIDC login (default)").action(async () => {
+      const { exec } = await import("child_process");
+      const startRes = await fetch(`${base}/v1/auth/start`);
+      if (!startRes.ok) fatal(`Auth start failed (${startRes.status})`);
+      const { state, url: authUrl } = await startRes.json();
+      warn(`Login URL: ${clr.cyan}${authUrl}${clr.reset}`);
+      warn("Opening browser\u2026");
+      const opener = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+      exec(`${opener} "${authUrl}"`);
+      warn("Waiting for browser login\u2026 (Ctrl+C to cancel)");
+      let token;
+      const deadline = Date.now() + 3e5;
+      const startedAt = Date.now();
+      let attempt = 0;
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, attempt < 10 ? 1e3 : 2e3));
+        attempt++;
+        try {
+          const pollRes = await fetch(`${base}/v1/auth/poll/${state}`);
+          if (!pollRes.ok) continue;
+          const body = await pollRes.json();
+          if (body.status === "done" && body.token) {
+            token = body.token;
+            break;
+          }
+          if (body.status === "expired") fatal("Auth session expired \u2014 run login again.");
+        } catch {
+        }
+        if (attempt % 5 === 0) {
+          const elapsed = Math.round((Date.now() - startedAt) / 1e3);
+          process.stderr.write(`\r  Waiting for browser\u2026 ${elapsed}s`);
+        }
+      }
+      if (!token) {
+        process.stderr.write("\n");
+        fatal("Login timed out.");
+      }
+      process.stderr.write("\n");
+      const meRes = await fetch(`${base}/v1/account/me`, { headers: { Authorization: `Bearer ${token}` } });
+      if (!meRes.ok) fatal(`Failed to fetch user info (${meRes.status})`);
+      const me = await meRes.json();
+      const orgSlug = me.org.slug;
+      let ws = { id: "", slug: "default" };
+      let prj = { id: "", slug: "default" };
+      let env = { id: "", slug: "production" };
+      try {
+        const headers = { Authorization: `Bearer ${token}` };
+        const wsRes = await fetch(`${base}/v1/orgs/${orgSlug}/workspaces`, { headers });
+        if (wsRes.ok) {
+          const b = await wsRes.json();
+          if (b.workspaces[0]) ws = b.workspaces[0];
+        }
+        if (ws.id) {
+          const prjRes = await fetch(`${base}/v1/orgs/${orgSlug}/workspaces/${ws.slug}/projects`, { headers });
+          if (prjRes.ok) {
+            const b = await prjRes.json();
+            if (b.projects[0]) prj = b.projects[0];
+          }
+        }
+        if (prj.id) {
+          const envRes = await fetch(`${base}/v1/orgs/${orgSlug}/workspaces/${ws.slug}/projects/${prj.slug}/envs`, { headers });
+          if (envRes.ok) {
+            const b = await envRes.json();
+            if (b.envs[0]) env = b.envs[0];
+          }
+        }
+      } catch {
+      }
+      const result = {
+        token,
+        user: me.user,
+        role: me.role,
+        org: { id: me.org.id, slug: orgSlug },
+        workspace: ws,
+        project: prj,
+        env
+      };
+      deps.onLoginSuccess(result);
+      success("Logged in.");
+      const rows = [];
+      if (result.user) {
+        rows.push(["user", result.user.email], ["role", result.role ?? "\u2014"]);
+      }
+      rows.push(
+        ["org", result.org.slug],
+        ["workspace", result.workspace.slug],
+        ["project", result.project.slug],
+        ["env", result.env.slug],
+        ["token", token.slice(0, 14) + "\u2026"]
+      );
+      kv(rows);
+    })
+  );
+  cmd.action(async () => {
+    const sub = cmd.commands.find((c) => c.name() === "browser");
+    await sub.parseAsync([], { from: "user" });
+  });
+  return cmd;
+}
+function buildLogoutCommand(deps) {
+  const { ctx } = deps;
+  return new Command("logout").description("Remove saved token and clear active context").option("--all", "Remove all stored org tokens").action((opts) => {
+    const cfg = ctx.loadConfig();
+    if (opts.all) {
+      delete cfg["orgs"];
+      delete cfg["activeOrg"];
+    } else {
+      const activeOrg = cfg["activeOrg"];
+      const orgs = cfg["orgs"];
+      if (activeOrg && orgs) {
+        delete orgs[activeOrg];
+        if (Object.keys(orgs).length === 0) delete cfg["orgs"];
+      }
+      delete cfg["activeOrg"];
+    }
+    ctx.clearContext();
+    ctx.saveConfig(cfg);
+    success(opts.all ? "All tokens removed." : "Logged out.");
+  });
+}
+function buildWhoamiCommand(deps) {
+  const { ctx } = deps;
+  const cli = deps.cliName ?? "cli";
+  return new Command("whoami").alias("wh").description("Show active token and context").action(() => {
+    const cfg = ctx.loadConfig();
+    const activeOrg = cfg["activeOrg"];
+    const orgs = cfg["orgs"];
+    const token = (activeOrg && orgs?.[activeOrg]?.token) ?? cfg["token"];
+    if (!token) {
+      warn(`No token set. Run: ${cli} login`);
+      return;
+    }
+    const rows = [["token", clr.cyan + token.slice(0, 14) + "\u2026" + clr.reset]];
+    if (activeOrg) rows.push(["org", clr.bold + activeOrg + clr.reset]);
+    if (orgs && Object.keys(orgs).length > 1) {
+      rows.push(["other orgs", clr.dim + Object.keys(orgs).filter((s) => s !== activeOrg).join(", ") + clr.reset]);
+    }
+    kv(rows);
+  });
+}
+function buildMeCommand(deps) {
+  const { http } = deps;
+  const cli = deps.cliName ?? "cli";
+  return new Command("me").description("Current user and org membership").option(...outputOption()).action(async (opts) => {
+    const res = await http.get("/v1/account/me").catch((e) => {
+      console.error(e.message);
+      process.exit(1);
+    });
+    if (!res.user) {
+      warn(`Org-level token (no user identity). Run: ${cli} login`);
+      kv([["org_id", res.org.id]]);
+      return;
+    }
+    printOutput(res, opts.output, () => kv([
+      ["email", res.user.email],
+      ["name", res.user.name ?? "\u2014"],
+      ["role", clr.bold + (res.role ?? "\u2014") + clr.reset],
+      ["org", res.org.slug ?? res.org.id],
+      ["user_id", res.user.id]
+    ]));
+  });
+}
+function buildMembersCommand(deps) {
+  const { http } = deps;
+  const cmd = new Command("members").alias("member").description("Org member management").enablePositionalOptions().option(...outputOption()).action(async (opts) => {
+    const res = await http.get("/v1/account/members").catch((e) => {
+      console.error(e.message);
+      process.exit(1);
+    });
+    printOutput(res.members, opts.output, (wide) => {
+      table(res.members, [
+        { key: "email", label: "EMAIL" },
+        { key: "name", label: "NAME", fmt: (v) => v ?? "\u2014" },
+        { key: "role", label: "ROLE" },
+        { key: "joinedAt", label: "JOINED", fmt: (v) => fmtDate(v), wide: true },
+        { key: "userId", label: "USER ID", wide: true }
+      ], { wide, emptyHint: `No members yet.` });
+    }, "email");
+  });
+  cmd.addCommand(
+    new Command("role").argument("<ref>").argument("<role>").description("Change member role (admin+). ref = email or userId").action(async (ref, role) => {
+      await http.patch(`/v1/account/members/${ref}/role`, { role }).catch((e) => {
+        console.error(e.message);
+        process.exit(1);
+      });
+      success(`Role updated \u2192 ${role}`);
+    })
+  );
+  cmd.addCommand(
+    new Command("remove").argument("<ref>").description("Remove member from org (admin+). ref = email or userId").action(async (ref) => {
+      await http.del(`/v1/account/members/${ref}`).catch((e) => {
+        console.error(e.message);
+        process.exit(1);
+      });
+      success("Member removed.");
+    })
+  );
+  return cmd;
+}
+function buildTokensCommand(deps) {
+  const { http } = deps;
+  const cmd = new Command("tokens").alias("token").description("API token management").enablePositionalOptions().option(...outputOption()).action(async (opts) => {
+    const res = await http.get("/v1/account/me/tokens").catch((e) => {
+      console.error(e.message);
+      process.exit(1);
+    });
+    printOutput(res.tokens, opts.output, (wide) => {
+      table(res.tokens, [
+        { key: "keyPrefix", label: "PREFIX" },
+        { key: "name", label: "NAME" },
+        { key: "lastUsedAt", label: "LAST USED", fmt: (v) => fmtDate(v) },
+        { key: "createdAt", label: "CREATED", fmt: (v) => fmtDate(v), wide: true },
+        { key: "id", label: "FULL ID", wide: true }
+      ], { wide, emptyHint: "No tokens." });
+    }, "keyPrefix");
+  });
+  cmd.addCommand(
+    new Command("create").description("Create a new API token").requiredOption("--name <name>", "Token name").action(async (opts) => {
+      const res = await http.post("/v1/account/me/tokens", { name: opts.name }).catch((e) => {
+        console.error(e.message);
+        process.exit(1);
+      });
+      success("Token created \u2014 save it now, it will not be shown again:");
+      console.log(`
+  ${clr.cyan}${clr.bold}${res.token.raw}${clr.reset}
+`);
+      kv([["prefix", res.token.keyPrefix], ["name", res.token.name]]);
+    })
+  );
+  cmd.addCommand(
+    new Command("revoke").argument("<ref>").description("Revoke a token. ref = prefix or full id").action(async (ref) => {
+      await http.del(`/v1/account/me/tokens/${ref}`).catch((e) => {
+        console.error(e.message);
+        process.exit(1);
+      });
+      success(`Token ${ref} revoked.`);
+    })
+  );
+  return cmd;
+}
+function buildAccountCommand(deps) {
+  const cmd = new Command("account").alias("acc").description("Identity, members, and token management");
+  cmd.addCommand(buildLoginCommand(deps));
+  cmd.addCommand(buildLogoutCommand(deps));
+  cmd.addCommand(buildWhoamiCommand(deps));
+  cmd.addCommand(buildMeCommand(deps));
+  cmd.addCommand(buildMembersCommand(deps));
+  cmd.addCommand(buildTokensCommand(deps));
+  return cmd;
+}
+export {
+  buildAccountCommand as accountCommand,
+  buildAccountCommand,
+  buildLoginCommand,
+  buildLogoutCommand,
+  buildMeCommand,
+  buildMembersCommand,
+  buildTokensCommand,
+  buildWhoamiCommand
+};

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+import { O as OrgRole } from './memberships-Re0HbIz4.js';
+import 'drizzle-orm/pg-core';
+
+interface User {
+    id: string;
+    subject: string;
+    issuer: string;
+    email: string;
+    name: string | null;
+    picture: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface OrgMembership {
+    id: string;
+    userId: string;
+    organizationId: string;
+    role: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface ApiToken {
+    id: string;
+    organizationId: string;
+    userId: string | null;
+    name: string;
+    tokenHash: string;
+    keyPrefix: string;
+    scopes: string;
+    lastUsedAt: number | null;
+    expiresAt: number | null;
+    revokedAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface OidcIdentity {
+    subject: string;
+    issuer: string;
+    email: string;
+    name?: string;
+    picture?: string;
+}
+
+type AnyDB$2 = any;
+declare function createUserRepo(db: AnyDB$2, schema: {
+    users: any;
+}): {
+    upsert(identity: OidcIdentity): Promise<User>;
+    findById(id: string): Promise<User | undefined>;
+    findBySubject(issuer: string, subject: string): Promise<User | undefined>;
+    findByEmail(email: string): Promise<User | undefined>;
+};
+type UserRepo = ReturnType<typeof createUserRepo>;
+
+type AnyDB$1 = any;
+declare function createOrgMembershipRepo(db: AnyDB$1, schema: {
+    orgMemberships: any;
+}): {
+    add(userId: string, organizationId: string, role: OrgRole): Promise<OrgMembership>;
+    updateRole(userId: string, organizationId: string, role: OrgRole): Promise<void>;
+    remove(userId: string, organizationId: string): Promise<void>;
+    find(userId: string, organizationId: string): Promise<OrgMembership | undefined>;
+    listByUser(userId: string): Promise<OrgMembership[]>;
+    listByOrg(organizationId: string): Promise<OrgMembership[]>;
+    firstForUser(userId: string): Promise<OrgMembership | undefined>;
+};
+type OrgMembershipRepo = ReturnType<typeof createOrgMembershipRepo>;
+
+type AnyDB = any;
+declare function createApiTokenRepo(db: AnyDB, schema: {
+    apiTokens: any;
+}): {
+    create(data: {
+        organizationId: string;
+        name: string;
+        tokenHash: string;
+        keyPrefix: string;
+        userId?: string;
+        scopes?: string[];
+        expiresAt?: number;
+    }): Promise<ApiToken>;
+    findByHash(tokenHash: string): Promise<ApiToken | undefined>;
+    touch(id: string): Promise<void>;
+    revoke(id: string): Promise<void>;
+    listByOrg(organizationId: string): Promise<ApiToken[]>;
+    listByUser(userId: string): Promise<ApiToken[]>;
+    countActive(organizationId: string, userId?: string): Promise<number>;
+};
+type ApiTokenRepo = ReturnType<typeof createApiTokenRepo>;
+
+export { type ApiToken, type ApiTokenRepo, type OidcIdentity, type OrgMembership, type OrgMembershipRepo, OrgRole, type User, type UserRepo, createApiTokenRepo, createOrgMembershipRepo, createUserRepo };

package/dist/index.js

@@ -0,0 +1,135 @@
+// src/repo/users.ts
+import { and, eq } from "drizzle-orm";
+import { generateId } from "@baseworks/core";
+function createUserRepo(db, schema) {
+  const { users } = schema;
+  return {
+    async upsert(identity) {
+      const now = Date.now();
+      const existing = await db.select().from(users).where(and(eq(users.subject, identity.subject), eq(users.issuer, identity.issuer))).limit(1).then((r) => r[0]);
+      if (existing) {
+        await db.update(users).set({ email: identity.email, name: identity.name ?? null, picture: identity.picture ?? null, updatedAt: now }).where(eq(users.id, existing.id));
+        return { ...existing, email: identity.email, name: identity.name ?? null, picture: identity.picture ?? null, updatedAt: now };
+      }
+      const row = {
+        id: generateId(),
+        subject: identity.subject,
+        issuer: identity.issuer,
+        email: identity.email,
+        name: identity.name ?? null,
+        picture: identity.picture ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(users).values(row);
+      return row;
+    },
+    async findById(id) {
+      const rows = await db.select().from(users).where(eq(users.id, id)).limit(1);
+      return rows[0];
+    },
+    async findBySubject(issuer, subject) {
+      const rows = await db.select().from(users).where(and(eq(users.issuer, issuer), eq(users.subject, subject))).limit(1);
+      return rows[0];
+    },
+    async findByEmail(email) {
+      const rows = await db.select().from(users).where(eq(users.email, email)).limit(1);
+      return rows[0];
+    }
+  };
+}
+
+// src/repo/memberships.ts
+import { and as and2, eq as eq2 } from "drizzle-orm";
+import { generateId as generateId2 } from "@baseworks/core";
+function createOrgMembershipRepo(db, schema) {
+  const { orgMemberships } = schema;
+  return {
+    async add(userId, organizationId, role) {
+      const now = Date.now();
+      const row = { id: generateId2(), userId, organizationId, role, createdAt: now, updatedAt: now };
+      await db.insert(orgMemberships).values(row).onConflictDoNothing();
+      return row;
+    },
+    async updateRole(userId, organizationId, role) {
+      await db.update(orgMemberships).set({ role, updatedAt: Date.now() }).where(and2(eq2(orgMemberships.userId, userId), eq2(orgMemberships.organizationId, organizationId)));
+    },
+    async remove(userId, organizationId) {
+      await db.delete(orgMemberships).where(and2(eq2(orgMemberships.userId, userId), eq2(orgMemberships.organizationId, organizationId)));
+    },
+    async find(userId, organizationId) {
+      const rows = await db.select().from(orgMemberships).where(and2(eq2(orgMemberships.userId, userId), eq2(orgMemberships.organizationId, organizationId))).limit(1);
+      return rows[0];
+    },
+    async listByUser(userId) {
+      return db.select().from(orgMemberships).where(eq2(orgMemberships.userId, userId));
+    },
+    async listByOrg(organizationId) {
+      return db.select().from(orgMemberships).where(eq2(orgMemberships.organizationId, organizationId));
+    },
+    async firstForUser(userId) {
+      const rows = await db.select().from(orgMemberships).where(eq2(orgMemberships.userId, userId)).limit(1);
+      return rows[0];
+    }
+  };
+}
+
+// src/repo/api-tokens.ts
+import { and as and3, eq as eq3, isNull } from "drizzle-orm";
+import { generateId as generateId3 } from "@baseworks/core";
+function createApiTokenRepo(db, schema) {
+  const { apiTokens } = schema;
+  return {
+    async create(data) {
+      const now = Date.now();
+      const row = {
+        id: generateId3(),
+        organizationId: data.organizationId,
+        userId: data.userId ?? null,
+        name: data.name,
+        tokenHash: data.tokenHash,
+        keyPrefix: data.keyPrefix,
+        scopes: JSON.stringify(data.scopes ?? []),
+        lastUsedAt: null,
+        expiresAt: data.expiresAt ?? null,
+        revokedAt: null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(apiTokens).values(row);
+      return row;
+    },
+    async findByHash(tokenHash) {
+      const rows = await db.select().from(apiTokens).where(and3(eq3(apiTokens.tokenHash, tokenHash), isNull(apiTokens.revokedAt))).limit(1);
+      return rows[0];
+    },
+    async touch(id) {
+      await db.update(apiTokens).set({ lastUsedAt: Date.now(), updatedAt: Date.now() }).where(eq3(apiTokens.id, id));
+    },
+    async revoke(id) {
+      const now = Date.now();
+      await db.update(apiTokens).set({ revokedAt: now, updatedAt: now }).where(eq3(apiTokens.id, id));
+    },
+    async listByOrg(organizationId) {
+      return db.select().from(apiTokens).where(and3(eq3(apiTokens.organizationId, organizationId), isNull(apiTokens.revokedAt)));
+    },
+    async listByUser(userId) {
+      return db.select().from(apiTokens).where(and3(eq3(apiTokens.userId, userId), isNull(apiTokens.revokedAt)));
+    },
+    async countActive(organizationId, userId) {
+      const rows = await db.select({ id: apiTokens.id }).from(apiTokens).where(
+        and3(
+          eq3(apiTokens.organizationId, organizationId),
+          isNull(apiTokens.revokedAt),
+          userId ? eq3(apiTokens.userId, userId) : isNull(apiTokens.userId)
+        )
+      );
+      return rows.length;
+    }
+  };
+}
+export {
+  createApiTokenRepo,
+  createOrgMembershipRepo,
+  createUserRepo
+};

package/dist/memberships-Re0HbIz4.d.ts

@@ -0,0 +1,117 @@
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+
+declare const OrgRoles: readonly ["admin", "member", "viewer"];
+type OrgRole = typeof OrgRoles[number];
+declare const orgMemberships: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "org_memberships";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "org_memberships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "user_id";
+            tableName: "org_memberships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: drizzle_orm_pg_core.PgColumn<{
+            name: "organization_id";
+            tableName: "org_memberships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: drizzle_orm_pg_core.PgColumn<{
+            name: "role";
+            tableName: "org_memberships";
+            dataType: "string";
+            columnType: "PgText";
+            data: "admin" | "member" | "viewer";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "admin" | "member" | "viewer";
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "org_memberships";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "org_memberships";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+
+export { type OrgRole as O, OrgRoles as a, orgMemberships as o };