weave-typescript 0.12.0 → 0.14.0

package/dist/weavesql/atcdb/event_sql.d.ts

@@ -0,0 +1,101 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const insertEventQuery = "-- name: InsertEvent :one\nINSERT INTO atc.events (\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8\n)\nRETURNING id, tenant_id, run_id, sequence, type, data, causation_id, correlation_id, occurred_at, transaction_id";
+export interface InsertEventArgs {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+}
+export interface InsertEventRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+    transactionId: string;
+}
+export declare function insertEvent(client: Client, args: InsertEventArgs): Promise<InsertEventRow | null>;
+export declare const getCurrentVersionQuery = "-- name: GetCurrentVersion :one\nSELECT COALESCE(MAX(sequence), 0)::BIGINT AS version\nFROM atc.events\nWHERE tenant_id = $1\n  AND run_id = $2";
+export interface GetCurrentVersionArgs {
+    tenantId: string;
+    runId: string;
+}
+export interface GetCurrentVersionRow {
+    version: string;
+}
+export declare function getCurrentVersion(client: Client, args: GetCurrentVersionArgs): Promise<GetCurrentVersionRow | null>;
+export declare const loadEventsQuery = "-- name: LoadEvents :many\nSELECT\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id,\n    occurred_at\nFROM atc.events\nWHERE tenant_id = $1\n  AND run_id = $2\n  AND sequence > $3\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC";
+export interface LoadEventsArgs {
+    tenantId: string;
+    runId: string;
+    afterSequence: string;
+}
+export interface LoadEventsRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function loadEvents(client: Client, args: LoadEventsArgs): Promise<LoadEventsRow[]>;
+export declare const loadAllEventsQuery = "-- name: LoadAllEvents :many\nSELECT\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id,\n    occurred_at\nFROM atc.events\nWHERE tenant_id = $1\n  AND run_id = $2\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC";
+export interface LoadAllEventsArgs {
+    tenantId: string;
+    runId: string;
+}
+export interface LoadAllEventsRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function loadAllEvents(client: Client, args: LoadAllEventsArgs): Promise<LoadAllEventsRow[]>;
+export declare const listEventsByTypeQuery = "-- name: ListEventsByType :many\nSELECT\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id,\n    occurred_at\nFROM atc.events\nWHERE tenant_id = $1\n  AND run_id = $2\n  AND type = $3\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC";
+export interface ListEventsByTypeArgs {
+    tenantId: string;
+    runId: string;
+    eventType: string;
+}
+export interface ListEventsByTypeRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function listEventsByType(client: Client, args: ListEventsByTypeArgs): Promise<ListEventsByTypeRow[]>;
+export declare const lockRunQuery = "-- name: LockRun :exec\nSELECT pg_advisory_xact_lock($1::int, hashtext($2::text || ':' || $3::text))";
+export interface LockRunArgs {
+    lockNamespace: number;
+    tenantId: string;
+    runId: string;
+}
+export interface LockRunRow {
+    pgAdvisoryXactLock: string;
+}
+export declare function lockRun(client: Client, args: LockRunArgs): Promise<void>;
+export {};

package/dist/weavesql/atcdb/event_sql.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockRunQuery = exports.listEventsByTypeQuery = exports.loadAllEventsQuery = exports.loadEventsQuery = exports.getCurrentVersionQuery = exports.insertEventQuery = void 0;
+exports.insertEvent = insertEvent;
+exports.getCurrentVersion = getCurrentVersion;
+exports.loadEvents = loadEvents;
+exports.loadAllEvents = loadAllEvents;
+exports.listEventsByType = listEventsByType;
+exports.lockRun = lockRun;
+exports.insertEventQuery = `-- name: InsertEvent :one
+INSERT INTO atc.events (
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8
+)
+RETURNING id, tenant_id, run_id, sequence, type, data, causation_id, correlation_id, occurred_at, transaction_id`;
+async function insertEvent(client, args) {
+    const result = await client.query({
+        text: exports.insertEventQuery,
+        values: [args.id, args.tenantId, args.runId, args.sequence, args.type, args.data, args.causationId, args.correlationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        tenantId: row[1],
+        runId: row[2],
+        sequence: row[3],
+        type: row[4],
+        data: row[5],
+        causationId: row[6],
+        correlationId: row[7],
+        occurredAt: row[8],
+        transactionId: row[9]
+    };
+}
+exports.getCurrentVersionQuery = `-- name: GetCurrentVersion :one
+SELECT COALESCE(MAX(sequence), 0)::BIGINT AS version
+FROM atc.events
+WHERE tenant_id = $1
+  AND run_id = $2`;
+async function getCurrentVersion(client, args) {
+    const result = await client.query({
+        text: exports.getCurrentVersionQuery,
+        values: [args.tenantId, args.runId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        version: row[0]
+    };
+}
+exports.loadEventsQuery = `-- name: LoadEvents :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND run_id = $2
+  AND sequence > $3
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC`;
+async function loadEvents(client, args) {
+    const result = await client.query({
+        text: exports.loadEventsQuery,
+        values: [args.tenantId, args.runId, args.afterSequence],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            runId: row[2],
+            sequence: row[3],
+            type: row[4],
+            data: row[5],
+            causationId: row[6],
+            correlationId: row[7],
+            occurredAt: row[8]
+        };
+    });
+}
+exports.loadAllEventsQuery = `-- name: LoadAllEvents :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND run_id = $2
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC`;
+async function loadAllEvents(client, args) {
+    const result = await client.query({
+        text: exports.loadAllEventsQuery,
+        values: [args.tenantId, args.runId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            runId: row[2],
+            sequence: row[3],
+            type: row[4],
+            data: row[5],
+            causationId: row[6],
+            correlationId: row[7],
+            occurredAt: row[8]
+        };
+    });
+}
+exports.listEventsByTypeQuery = `-- name: ListEventsByType :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND run_id = $2
+  AND type = $3
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC`;
+async function listEventsByType(client, args) {
+    const result = await client.query({
+        text: exports.listEventsByTypeQuery,
+        values: [args.tenantId, args.runId, args.eventType],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            runId: row[2],
+            sequence: row[3],
+            type: row[4],
+            data: row[5],
+            causationId: row[6],
+            correlationId: row[7],
+            occurredAt: row[8]
+        };
+    });
+}
+exports.lockRunQuery = `-- name: LockRun :exec
+SELECT pg_advisory_xact_lock($1::int, hashtext($2::text || ':' || $3::text))`;
+async function lockRun(client, args) {
+    await client.query({
+        text: exports.lockRunQuery,
+        values: [args.lockNamespace, args.tenantId, args.runId],
+        rowMode: "array"
+    });
+}

package/dist/weavesql/atcdb/mailbox_sql.d.ts

@@ -0,0 +1,43 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const ensureMailboxCursorQuery = "-- name: EnsureMailboxCursor :exec\nINSERT INTO atc.mailbox_cursors (tenant_id, process_id)\nVALUES ($1, $2)\nON CONFLICT (tenant_id, process_id) DO NOTHING";
+export interface EnsureMailboxCursorArgs {
+    tenantId: string;
+    processId: string;
+}
+export declare function ensureMailboxCursor(client: Client, args: EnsureMailboxCursorArgs): Promise<void>;
+export declare const lockMailboxCursorQuery = "-- name: LockMailboxCursor :one\nSELECT\n    last_acked_sequence,\n    last_processed_transaction_id::text AS last_processed_transaction_id\nFROM atc.mailbox_cursors\nWHERE tenant_id = $1\n  AND process_id = $2\nFOR UPDATE";
+export interface LockMailboxCursorArgs {
+    tenantId: string;
+    processId: string;
+}
+export interface LockMailboxCursorRow {
+    lastAckedSequence: string;
+    lastProcessedTransactionId: string;
+}
+export declare function lockMailboxCursor(client: Client, args: LockMailboxCursorArgs): Promise<LockMailboxCursorRow | null>;
+export declare const readMailboxQuery = "-- name: ReadMailbox :many\nSELECT\n    sequence,\n    transaction_id::text AS transaction_id,\n    data\nFROM atc.events\nWHERE tenant_id = $1\n  AND data->>'to' = $2::text\n  AND data->>'category' IN ('protocol', 'semantic')\n  AND (\n      sequence > $3\n      OR (sequence = $3 AND transaction_id > $4::xid8)\n  )\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC\nLIMIT $5";
+export interface ReadMailboxArgs {
+    tenantId: string;
+    processId: string;
+    afterSequence: string;
+    afterTransactionId: string;
+    batchLimit: string;
+}
+export interface ReadMailboxRow {
+    sequence: string;
+    transactionId: string;
+    data: any | null;
+}
+export declare function readMailbox(client: Client, args: ReadMailboxArgs): Promise<ReadMailboxRow[]>;
+export declare const acknowledgeMailboxQuery = "-- name: AcknowledgeMailbox :exec\nUPDATE atc.mailbox_cursors\nSET\n    last_acked_sequence = $1,\n    last_processed_transaction_id = $2::xid8\nWHERE tenant_id = $3\n  AND process_id = $4";
+export interface AcknowledgeMailboxArgs {
+    lastSequence: string;
+    lastTransactionId: string;
+    tenantId: string;
+    processId: string;
+}
+export declare function acknowledgeMailbox(client: Client, args: AcknowledgeMailboxArgs): Promise<void>;
+export {};

package/dist/weavesql/atcdb/mailbox_sql.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acknowledgeMailboxQuery = exports.readMailboxQuery = exports.lockMailboxCursorQuery = exports.ensureMailboxCursorQuery = void 0;
+exports.ensureMailboxCursor = ensureMailboxCursor;
+exports.lockMailboxCursor = lockMailboxCursor;
+exports.readMailbox = readMailbox;
+exports.acknowledgeMailbox = acknowledgeMailbox;
+exports.ensureMailboxCursorQuery = `-- name: EnsureMailboxCursor :exec
+INSERT INTO atc.mailbox_cursors (tenant_id, process_id)
+VALUES ($1, $2)
+ON CONFLICT (tenant_id, process_id) DO NOTHING`;
+async function ensureMailboxCursor(client, args) {
+    await client.query({
+        text: exports.ensureMailboxCursorQuery,
+        values: [args.tenantId, args.processId],
+        rowMode: "array"
+    });
+}
+exports.lockMailboxCursorQuery = `-- name: LockMailboxCursor :one
+SELECT
+    last_acked_sequence,
+    last_processed_transaction_id::text AS last_processed_transaction_id
+FROM atc.mailbox_cursors
+WHERE tenant_id = $1
+  AND process_id = $2
+FOR UPDATE`;
+async function lockMailboxCursor(client, args) {
+    const result = await client.query({
+        text: exports.lockMailboxCursorQuery,
+        values: [args.tenantId, args.processId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        lastAckedSequence: row[0],
+        lastProcessedTransactionId: row[1]
+    };
+}
+exports.readMailboxQuery = `-- name: ReadMailbox :many
+SELECT
+    sequence,
+    transaction_id::text AS transaction_id,
+    data
+FROM atc.events
+WHERE tenant_id = $1
+  AND data->>'to' = $2::text
+  AND data->>'category' IN ('protocol', 'semantic')
+  AND (
+      sequence > $3
+      OR (sequence = $3 AND transaction_id > $4::xid8)
+  )
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC
+LIMIT $5`;
+async function readMailbox(client, args) {
+    const result = await client.query({
+        text: exports.readMailboxQuery,
+        values: [args.tenantId, args.processId, args.afterSequence, args.afterTransactionId, args.batchLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            sequence: row[0],
+            transactionId: row[1],
+            data: row[2]
+        };
+    });
+}
+exports.acknowledgeMailboxQuery = `-- name: AcknowledgeMailbox :exec
+UPDATE atc.mailbox_cursors
+SET
+    last_acked_sequence = $1,
+    last_processed_transaction_id = $2::xid8
+WHERE tenant_id = $3
+  AND process_id = $4`;
+async function acknowledgeMailbox(client, args) {
+    await client.query({
+        text: exports.acknowledgeMailboxQuery,
+        values: [args.lastSequence, args.lastTransactionId, args.tenantId, args.processId],
+        rowMode: "array"
+    });
+}

package/dist/weavesql/weavedb/project_sql.d.ts

@@ -2,118 +2,193 @@ import { QueryArrayConfig, QueryArrayResult } from "pg";
 interface Client {
     query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
 }
-export declare const createProjectQuery = "-- name: CreateProject :one\nINSERT INTO weave_v1.project (\n    id,\n    organization_id,\n    name,\n    slug,\n    description,\n    status\n)\nVALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6\n)\nRETURNING id, organization_id, name, slug, description, status, created_at, updated_at, archived_at";
+export declare const createProjectQuery = "-- name: CreateProject :one\nINSERT INTO weave.projects (\n    id,\n    organization_id,\n    slug,\n    name,\n    summary,\n    description,\n    status,\n    owner_user_id,\n    creator_user_id,\n    workspace_id,\n    git_repository,\n    start_date,\n    target_date,\n    source_system,\n    source_id,\n    source_metadata\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8,\n    $9,\n    $10,\n    $11,\n    $12,\n    $13,\n    $14,\n    $15,\n    $16\n)\nRETURNING\n    id,\n    organization_id,\n    slug,\n    name,\n    summary,\n    description,\n    status,\n    owner_user_id,\n    creator_user_id,\n    workspace_id,\n    git_repository,\n    start_date,\n    target_date,\n    source_system,\n    source_id,\n    source_metadata,\n    created_at,\n    updated_at";
 export interface CreateProjectArgs {
     id: string;
     organizationId: string;
-    name: string;
     slug: string;
+    name: string;
+    summary: string;
     description: string;
     status: string;
+    ownerUserId: string;
+    creatorUserId: string;
+    workspaceId: string;
+    gitRepository: string | null;
+    startDate: Date | null;
+    targetDate: Date | null;
+    sourceSystem: string | null;
+    sourceId: string | null;
+    sourceMetadata: any | null;
 }
 export interface CreateProjectRow {
     id: string;
     organizationId: string;
-    name: string;
     slug: string;
+    name: string;
+    summary: string;
     description: string;
     status: string;
+    ownerUserId: string;
+    creatorUserId: string;
+    workspaceId: string;
+    gitRepository: string | null;
+    startDate: Date | null;
+    targetDate: Date | null;
+    sourceSystem: string | null;
+    sourceId: string | null;
+    sourceMetadata: any | null;
     createdAt: Date;
     updatedAt: Date;
-    archivedAt: Date | null;
 }
 export declare function createProject(client: Client, args: CreateProjectArgs): Promise<CreateProjectRow | null>;
-export declare const getProjectQuery = "-- name: GetProject :one\nSELECT id, organization_id, name, slug, description, status, created_at, updated_at, archived_at\nFROM weave_v1.project\nWHERE id = $1";
-export interface GetProjectArgs {
+export declare const getProjectByIDQuery = "-- name: GetProjectByID :one\nSELECT\n    id,\n    organization_id,\n    slug,\n    name,\n    summary,\n    description,\n    status,\n    owner_user_id,\n    creator_user_id,\n    workspace_id,\n    git_repository,\n    start_date,\n    target_date,\n    source_system,\n    source_id,\n    source_metadata,\n    created_at,\n    updated_at\nFROM weave.projects\nWHERE organization_id = $1\n  AND id = $2";
+export interface GetProjectByIDArgs {
+    organizationId: string;
     id: string;
 }
-export interface GetProjectRow {
+export interface GetProjectByIDRow {
     id: string;
     organizationId: string;
-    name: string;
     slug: string;
+    name: string;
+    summary: string;
     description: string;
     status: string;
+    ownerUserId: string;
+    creatorUserId: string;
+    workspaceId: string;
+    gitRepository: string | null;
+    startDate: Date | null;
+    targetDate: Date | null;
+    sourceSystem: string | null;
+    sourceId: string | null;
+    sourceMetadata: any | null;
     createdAt: Date;
     updatedAt: Date;
-    archivedAt: Date | null;
 }
-export declare function getProject(client: Client, args: GetProjectArgs): Promise<GetProjectRow | null>;
-export declare const getProjectBySlugQuery = "-- name: GetProjectBySlug :one\nSELECT id, organization_id, name, slug, description, status, created_at, updated_at, archived_at\nFROM weave_v1.project\nWHERE organization_id = $1\n  AND slug = $2";
+export declare function getProjectByID(client: Client, args: GetProjectByIDArgs): Promise<GetProjectByIDRow | null>;
+export declare const getProjectBySlugQuery = "-- name: GetProjectBySlug :one\nSELECT\n    id,\n    organization_id,\n    slug,\n    name,\n    summary,\n    description,\n    status,\n    owner_user_id,\n    creator_user_id,\n    workspace_id,\n    git_repository,\n    start_date,\n    target_date,\n    source_system,\n    source_id,\n    source_metadata,\n    created_at,\n    updated_at\nFROM weave.projects\nWHERE organization_id = $1\n  AND slug = $2";
 export interface GetProjectBySlugArgs {
     organizationId: string;
-    slug: string;
+    projectSlug: string;
 }
 export interface GetProjectBySlugRow {
     id: string;
     organizationId: string;
-    name: string;
     slug: string;
+    name: string;
+    summary: string;
     description: string;
     status: string;
+    ownerUserId: string;
+    creatorUserId: string;
+    workspaceId: string;
+    gitRepository: string | null;
+    startDate: Date | null;
+    targetDate: Date | null;
+    sourceSystem: string | null;
+    sourceId: string | null;
+    sourceMetadata: any | null;
     createdAt: Date;
     updatedAt: Date;
-    archivedAt: Date | null;
 }
 export declare function getProjectBySlug(client: Client, args: GetProjectBySlugArgs): Promise<GetProjectBySlugRow | null>;
-export declare const listProjectsByOrganizationQuery = "-- name: ListProjectsByOrganization :many\nSELECT id, organization_id, name, slug, description, status, created_at, updated_at, archived_at\nFROM weave_v1.project\nWHERE organization_id = $1\n  AND ($2::BOOLEAN OR archived_at IS NULL)\nORDER BY created_at DESC\nLIMIT $4\nOFFSET $3";
-export interface ListProjectsByOrganizationArgs {
+export declare const listProjectsQuery = "-- name: ListProjects :many\nSELECT\n    id,\n    organization_id,\n    slug,\n    name,\n    summary,\n    description,\n    status,\n    owner_user_id,\n    creator_user_id,\n    workspace_id,\n    git_repository,\n    start_date,\n    target_date,\n    source_system,\n    source_id,\n    source_metadata,\n    created_at,\n    updated_at\nFROM weave.projects\nWHERE organization_id = $1\nORDER BY updated_at DESC, created_at DESC";
+export interface ListProjectsArgs {
     organizationId: string;
-    includeArchived: boolean;
-    pageOffset: string;
-    pageSize: string;
 }
-export interface ListProjectsByOrganizationRow {
+export interface ListProjectsRow {
     id: string;
     organizationId: string;
-    name: string;
     slug: string;
+    name: string;
+    summary: string;
     description: string;
     status: string;
+    ownerUserId: string;
+    creatorUserId: string;
+    workspaceId: string;
+    gitRepository: string | null;
+    startDate: Date | null;
+    targetDate: Date | null;
+    sourceSystem: string | null;
+    sourceId: string | null;
+    sourceMetadata: any | null;
     createdAt: Date;
     updatedAt: Date;
-    archivedAt: Date | null;
 }
-export declare function listProjectsByOrganization(client: Client, args: ListProjectsByOrganizationArgs): Promise<ListProjectsByOrganizationRow[]>;
-export declare const updateProjectQuery = "-- name: UpdateProject :one\nUPDATE weave_v1.project\nSET name = $1,\n    slug = $2,\n    description = $3,\n    status = $4,\n    updated_at = NOW()\nWHERE id = $5\nRETURNING id, organization_id, name, slug, description, status, created_at, updated_at, archived_at";
-export interface UpdateProjectArgs {
+export declare function listProjects(client: Client, args: ListProjectsArgs): Promise<ListProjectsRow[]>;
+export declare const updateProjectBySlugQuery = "-- name: UpdateProjectBySlug :one\nUPDATE weave.projects\nSET\n    name = $1,\n    summary = $2,\n    description = $3,\n    status = $4,\n    workspace_id = $5,\n    git_repository = $6,\n    start_date = $7,\n    target_date = $8,\n    source_system = $9,\n    source_id = $10,\n    source_metadata = $11,\n    updated_at = now()\nWHERE organization_id = $12\n  AND slug = $13\nRETURNING\n    id,\n    organization_id,\n    slug,\n    name,\n    summary,\n    description,\n    status,\n    owner_user_id,\n    creator_user_id,\n    workspace_id,\n    git_repository,\n    start_date,\n    target_date,\n    source_system,\n    source_id,\n    source_metadata,\n    created_at,\n    updated_at";
+export interface UpdateProjectBySlugArgs {
     name: string;
-    slug: string;
+    summary: string;
     description: string;
     status: string;
-    id: string;
+    workspaceId: string;
+    gitRepository: string | null;
+    startDate: Date | null;
+    targetDate: Date | null;
+    sourceSystem: string | null;
+    sourceId: string | null;
+    sourceMetadata: any | null;
+    organizationId: string;
+    projectSlug: string;
 }
-export interface UpdateProjectRow {
+export interface UpdateProjectBySlugRow {
     id: string;
     organizationId: string;
-    name: string;
     slug: string;
+    name: string;
+    summary: string;
     description: string;
     status: string;
+    ownerUserId: string;
+    creatorUserId: string;
+    workspaceId: string;
+    gitRepository: string | null;
+    startDate: Date | null;
+    targetDate: Date | null;
+    sourceSystem: string | null;
+    sourceId: string | null;
+    sourceMetadata: any | null;
     createdAt: Date;
     updatedAt: Date;
-    archivedAt: Date | null;
 }
-export declare function updateProject(client: Client, args: UpdateProjectArgs): Promise<UpdateProjectRow | null>;
-export declare const archiveProjectQuery = "-- name: ArchiveProject :one\nUPDATE weave_v1.project\nSET status = 'archived',\n    archived_at = NOW(),\n    updated_at = NOW()\nWHERE id = $1\nRETURNING id, organization_id, name, slug, description, status, created_at, updated_at, archived_at";
-export interface ArchiveProjectArgs {
-    id: string;
+export declare function updateProjectBySlug(client: Client, args: UpdateProjectBySlugArgs): Promise<UpdateProjectBySlugRow | null>;
+export declare const listProjectPermissionsQuery = "-- name: ListProjectPermissions :many\nSELECT\n    id,\n    project_id,\n    principal_kind,\n    principal_id,\n    principal_slug,\n    principal_display_name,\n    permission_level,\n    created_at\nFROM weave.project_shares\nWHERE organization_id = $1\n  AND project_id = $2\nORDER BY principal_kind ASC, principal_display_name ASC";
+export interface ListProjectPermissionsArgs {
+    organizationId: string;
+    projectId: string;
 }
-export interface ArchiveProjectRow {
+export interface ListProjectPermissionsRow {
     id: string;
-    organizationId: string;
-    name: string;
-    slug: string;
-    description: string;
-    status: string;
+    projectId: string;
+    principalKind: string;
+    principalId: string;
+    principalSlug: string;
+    principalDisplayName: string;
+    permissionLevel: string;
     createdAt: Date;
-    updatedAt: Date;
-    archivedAt: Date | null;
 }
-export declare function archiveProject(client: Client, args: ArchiveProjectArgs): Promise<ArchiveProjectRow | null>;
-export declare const deleteProjectQuery = "-- name: DeleteProject :exec\nDELETE\nFROM weave_v1.project\nWHERE id = $1";
-export interface DeleteProjectArgs {
+export declare function listProjectPermissions(client: Client, args: ListProjectPermissionsArgs): Promise<ListProjectPermissionsRow[]>;
+export declare const listProjectActivityQuery = "-- name: ListProjectActivity :many\nSELECT\n    id,\n    project_id,\n    task_id,\n    event_type,\n    actor_id,\n    actor_slug,\n    actor_label,\n    description,\n    metadata,\n    created_at\nFROM weave.project_activity\nWHERE organization_id = $1\n  AND project_id = $2\nORDER BY created_at DESC\nLIMIT $3";
+export interface ListProjectActivityArgs {
+    organizationId: string;
+    projectId: string;
+    pageLimit: string;
+}
+export interface ListProjectActivityRow {
     id: string;
+    projectId: string;
+    taskId: string | null;
+    eventType: string;
+    actorId: string | null;
+    actorSlug: string | null;
+    actorLabel: string;
+    description: string;
+    metadata: any | null;
+    createdAt: Date;
 }
-export declare function deleteProject(client: Client, args: DeleteProjectArgs): Promise<void>;
+export declare function listProjectActivity(client: Client, args: ListProjectActivityArgs): Promise<ListProjectActivityRow[]>;
 export {};