weave-typescript 0.15.0 → 0.16.0

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

@@ -98,4 +98,72 @@ export interface LockRunRow {
     pgAdvisoryXactLock: string;
 }
 export declare function lockRun(client: Client, args: LockRunArgs): Promise<void>;
+export declare const queryEventsByTypeQuery = "-- name: QueryEventsByType :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 type = $2\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\n  AND (\n      $3::timestamptz IS NULL\n      OR (occurred_at, sequence) < ($3::timestamptz, $4::bigint)\n  )\nORDER BY occurred_at DESC, sequence DESC\nLIMIT $5";
+export interface QueryEventsByTypeArgs {
+    tenantId: string;
+    eventType: string;
+    afterOccurredAt: Date;
+    afterSequence: string;
+    pageSize: string;
+}
+export interface QueryEventsByTypeRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function queryEventsByType(client: Client, args: QueryEventsByTypeArgs): Promise<QueryEventsByTypeRow[]>;
+export declare const queryEventsByTimeRangeQuery = "-- name: QueryEventsByTimeRange :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 occurred_at >= $2\n  AND occurred_at < $3\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY occurred_at ASC, sequence ASC\nLIMIT $4";
+export interface QueryEventsByTimeRangeArgs {
+    tenantId: string;
+    startTime: Date;
+    endTime: Date;
+    pageSize: string;
+}
+export interface QueryEventsByTimeRangeRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function queryEventsByTimeRange(client: Client, args: QueryEventsByTimeRangeArgs): Promise<QueryEventsByTimeRangeRow[]>;
+export declare const queryEventsByRunAndTypesQuery = "-- name: QueryEventsByRunAndTypes :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 = ANY($3::text[])\n  AND sequence > $4\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC\nLIMIT $5";
+export interface QueryEventsByRunAndTypesArgs {
+    tenantId: string;
+    runId: string;
+    eventTypes: string[];
+    afterSequence: string;
+    pageSize: string;
+}
+export interface QueryEventsByRunAndTypesRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function queryEventsByRunAndTypes(client: Client, args: QueryEventsByRunAndTypesArgs): Promise<QueryEventsByRunAndTypesRow[]>;
+export declare const countEventsByTypeQuery = "-- name: CountEventsByType :one\nSELECT COUNT(*)::BIGINT AS total\nFROM atc.events\nWHERE tenant_id = $1\n  AND type = $2\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())";
+export interface CountEventsByTypeArgs {
+    tenantId: string;
+    eventType: string;
+}
+export interface CountEventsByTypeRow {
+    total: string;
+}
+export declare function countEventsByType(client: Client, args: CountEventsByTypeArgs): Promise<CountEventsByTypeRow | null>;
 export {};

package/dist/weavesql/atcdb/event_sql.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lockRunQuery = exports.listEventsByTypeQuery = exports.loadAllEventsQuery = exports.loadEventsQuery = exports.getCurrentVersionQuery = exports.insertEventQuery = void 0;
+exports.countEventsByTypeQuery = exports.queryEventsByRunAndTypesQuery = exports.queryEventsByTimeRangeQuery = exports.queryEventsByTypeQuery = 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.queryEventsByType = queryEventsByType;
+exports.queryEventsByTimeRange = queryEventsByTimeRange;
+exports.queryEventsByRunAndTypes = queryEventsByRunAndTypes;
+exports.countEventsByType = countEventsByType;
 exports.insertEventQuery = `-- name: InsertEvent :one
 INSERT INTO atc.events (
     id,
@@ -189,3 +193,141 @@ async function lockRun(client, args) {
         rowMode: "array"
     });
 }
+exports.queryEventsByTypeQuery = `-- name: QueryEventsByType :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND type = $2
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+  AND (
+      $3::timestamptz IS NULL
+      OR (occurred_at, sequence) < ($3::timestamptz, $4::bigint)
+  )
+ORDER BY occurred_at DESC, sequence DESC
+LIMIT $5`;
+async function queryEventsByType(client, args) {
+    const result = await client.query({
+        text: exports.queryEventsByTypeQuery,
+        values: [args.tenantId, args.eventType, args.afterOccurredAt, args.afterSequence, args.pageSize],
+        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.queryEventsByTimeRangeQuery = `-- name: QueryEventsByTimeRange :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND occurred_at >= $2
+  AND occurred_at < $3
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY occurred_at ASC, sequence ASC
+LIMIT $4`;
+async function queryEventsByTimeRange(client, args) {
+    const result = await client.query({
+        text: exports.queryEventsByTimeRangeQuery,
+        values: [args.tenantId, args.startTime, args.endTime, args.pageSize],
+        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.queryEventsByRunAndTypesQuery = `-- name: QueryEventsByRunAndTypes :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 = ANY($3::text[])
+  AND sequence > $4
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC
+LIMIT $5`;
+async function queryEventsByRunAndTypes(client, args) {
+    const result = await client.query({
+        text: exports.queryEventsByRunAndTypesQuery,
+        values: [args.tenantId, args.runId, args.eventTypes, args.afterSequence, args.pageSize],
+        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.countEventsByTypeQuery = `-- name: CountEventsByType :one
+SELECT COUNT(*)::BIGINT AS total
+FROM atc.events
+WHERE tenant_id = $1
+  AND type = $2
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())`;
+async function countEventsByType(client, args) {
+    const result = await client.query({
+        text: exports.countEventsByTypeQuery,
+        values: [args.tenantId, args.eventType],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        total: row[0]
+    };
+}

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

@@ -0,0 +1,122 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const insertRunTemplateQuery = "-- name: InsertRunTemplate :one\nINSERT INTO atc.run_templates (\n    id,\n    tenant_id,\n    name,\n    version,\n    handler_type,\n    config,\n    security_context,\n    budget_context,\n    pinned_caller,\n    created_by\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8,\n    $9,\n    $10\n)\nRETURNING id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at";
+export interface InsertRunTemplateArgs {
+    id: string;
+    tenantId: string;
+    name: string;
+    version: number;
+    handlerType: string;
+    config: any;
+    securityContext: any | null;
+    budgetContext: any | null;
+    pinnedCaller: any | null;
+    createdBy: string;
+}
+export interface InsertRunTemplateRow {
+    id: string;
+    tenantId: string;
+    name: string;
+    version: number;
+    handlerType: string;
+    config: any;
+    securityContext: any | null;
+    budgetContext: any | null;
+    pinnedCaller: any | null;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function insertRunTemplate(client: Client, args: InsertRunTemplateArgs): Promise<InsertRunTemplateRow | null>;
+export declare const getRunTemplateQuery = "-- name: GetRunTemplate :one\nSELECT id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at\nFROM atc.run_templates\nWHERE tenant_id = $1\n  AND id = $2";
+export interface GetRunTemplateArgs {
+    tenantId: string;
+    id: string;
+}
+export interface GetRunTemplateRow {
+    id: string;
+    tenantId: string;
+    name: string;
+    version: number;
+    handlerType: string;
+    config: any;
+    securityContext: any | null;
+    budgetContext: any | null;
+    pinnedCaller: any | null;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function getRunTemplate(client: Client, args: GetRunTemplateArgs): Promise<GetRunTemplateRow | null>;
+export declare const getRunTemplateByNameQuery = "-- name: GetRunTemplateByName :one\nSELECT id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at\nFROM atc.run_templates\nWHERE tenant_id = $1\n  AND name = $2\nORDER BY version DESC\nLIMIT 1";
+export interface GetRunTemplateByNameArgs {
+    tenantId: string;
+    name: string;
+}
+export interface GetRunTemplateByNameRow {
+    id: string;
+    tenantId: string;
+    name: string;
+    version: number;
+    handlerType: string;
+    config: any;
+    securityContext: any | null;
+    budgetContext: any | null;
+    pinnedCaller: any | null;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function getRunTemplateByName(client: Client, args: GetRunTemplateByNameArgs): Promise<GetRunTemplateByNameRow | null>;
+export declare const listRunTemplatesQuery = "-- name: ListRunTemplates :many\nSELECT id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at\nFROM atc.run_templates\nWHERE tenant_id = $1\nORDER BY name ASC, version DESC";
+export interface ListRunTemplatesArgs {
+    tenantId: string;
+}
+export interface ListRunTemplatesRow {
+    id: string;
+    tenantId: string;
+    name: string;
+    version: number;
+    handlerType: string;
+    config: any;
+    securityContext: any | null;
+    budgetContext: any | null;
+    pinnedCaller: any | null;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function listRunTemplates(client: Client, args: ListRunTemplatesArgs): Promise<ListRunTemplatesRow[]>;
+export declare const updateRunTemplateQuery = "-- name: UpdateRunTemplate :one\nUPDATE atc.run_templates\nSET\n    config = $1,\n    security_context = $2,\n    budget_context = $3,\n    pinned_caller = $4,\n    version = version + 1,\n    updated_at = now()\nWHERE tenant_id = $5\n  AND id = $6\nRETURNING id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at";
+export interface UpdateRunTemplateArgs {
+    config: any;
+    securityContext: any | null;
+    budgetContext: any | null;
+    pinnedCaller: any | null;
+    tenantId: string;
+    id: string;
+}
+export interface UpdateRunTemplateRow {
+    id: string;
+    tenantId: string;
+    name: string;
+    version: number;
+    handlerType: string;
+    config: any;
+    securityContext: any | null;
+    budgetContext: any | null;
+    pinnedCaller: any | null;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function updateRunTemplate(client: Client, args: UpdateRunTemplateArgs): Promise<UpdateRunTemplateRow | null>;
+export declare const deleteRunTemplateQuery = "-- name: DeleteRunTemplate :exec\nDELETE FROM atc.run_templates\nWHERE tenant_id = $1\n  AND id = $2";
+export interface DeleteRunTemplateArgs {
+    tenantId: string;
+    id: string;
+}
+export declare function deleteRunTemplate(client: Client, args: DeleteRunTemplateArgs): Promise<void>;
+export {};

package/dist/weavesql/atcdb/run_template_sql.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteRunTemplateQuery = exports.updateRunTemplateQuery = exports.listRunTemplatesQuery = exports.getRunTemplateByNameQuery = exports.getRunTemplateQuery = exports.insertRunTemplateQuery = void 0;
+exports.insertRunTemplate = insertRunTemplate;
+exports.getRunTemplate = getRunTemplate;
+exports.getRunTemplateByName = getRunTemplateByName;
+exports.listRunTemplates = listRunTemplates;
+exports.updateRunTemplate = updateRunTemplate;
+exports.deleteRunTemplate = deleteRunTemplate;
+exports.insertRunTemplateQuery = `-- name: InsertRunTemplate :one
+INSERT INTO atc.run_templates (
+    id,
+    tenant_id,
+    name,
+    version,
+    handler_type,
+    config,
+    security_context,
+    budget_context,
+    pinned_caller,
+    created_by
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10
+)
+RETURNING id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at`;
+async function insertRunTemplate(client, args) {
+    const result = await client.query({
+        text: exports.insertRunTemplateQuery,
+        values: [args.id, args.tenantId, args.name, args.version, args.handlerType, args.config, args.securityContext, args.budgetContext, args.pinnedCaller, args.createdBy],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        tenantId: row[1],
+        name: row[2],
+        version: row[3],
+        handlerType: row[4],
+        config: row[5],
+        securityContext: row[6],
+        budgetContext: row[7],
+        pinnedCaller: row[8],
+        createdBy: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.getRunTemplateQuery = `-- name: GetRunTemplate :one
+SELECT id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at
+FROM atc.run_templates
+WHERE tenant_id = $1
+  AND id = $2`;
+async function getRunTemplate(client, args) {
+    const result = await client.query({
+        text: exports.getRunTemplateQuery,
+        values: [args.tenantId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        tenantId: row[1],
+        name: row[2],
+        version: row[3],
+        handlerType: row[4],
+        config: row[5],
+        securityContext: row[6],
+        budgetContext: row[7],
+        pinnedCaller: row[8],
+        createdBy: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.getRunTemplateByNameQuery = `-- name: GetRunTemplateByName :one
+SELECT id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at
+FROM atc.run_templates
+WHERE tenant_id = $1
+  AND name = $2
+ORDER BY version DESC
+LIMIT 1`;
+async function getRunTemplateByName(client, args) {
+    const result = await client.query({
+        text: exports.getRunTemplateByNameQuery,
+        values: [args.tenantId, args.name],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        tenantId: row[1],
+        name: row[2],
+        version: row[3],
+        handlerType: row[4],
+        config: row[5],
+        securityContext: row[6],
+        budgetContext: row[7],
+        pinnedCaller: row[8],
+        createdBy: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.listRunTemplatesQuery = `-- name: ListRunTemplates :many
+SELECT id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at
+FROM atc.run_templates
+WHERE tenant_id = $1
+ORDER BY name ASC, version DESC`;
+async function listRunTemplates(client, args) {
+    const result = await client.query({
+        text: exports.listRunTemplatesQuery,
+        values: [args.tenantId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            name: row[2],
+            version: row[3],
+            handlerType: row[4],
+            config: row[5],
+            securityContext: row[6],
+            budgetContext: row[7],
+            pinnedCaller: row[8],
+            createdBy: row[9],
+            createdAt: row[10],
+            updatedAt: row[11]
+        };
+    });
+}
+exports.updateRunTemplateQuery = `-- name: UpdateRunTemplate :one
+UPDATE atc.run_templates
+SET
+    config = $1,
+    security_context = $2,
+    budget_context = $3,
+    pinned_caller = $4,
+    version = version + 1,
+    updated_at = now()
+WHERE tenant_id = $5
+  AND id = $6
+RETURNING id, tenant_id, name, version, handler_type, config, security_context, budget_context, pinned_caller, created_by, created_at, updated_at`;
+async function updateRunTemplate(client, args) {
+    const result = await client.query({
+        text: exports.updateRunTemplateQuery,
+        values: [args.config, args.securityContext, args.budgetContext, args.pinnedCaller, args.tenantId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        tenantId: row[1],
+        name: row[2],
+        version: row[3],
+        handlerType: row[4],
+        config: row[5],
+        securityContext: row[6],
+        budgetContext: row[7],
+        pinnedCaller: row[8],
+        createdBy: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.deleteRunTemplateQuery = `-- name: DeleteRunTemplate :exec
+DELETE FROM atc.run_templates
+WHERE tenant_id = $1
+  AND id = $2`;
+async function deleteRunTemplate(client, args) {
+    await client.query({
+        text: exports.deleteRunTemplateQuery,
+        values: [args.tenantId, args.id],
+        rowMode: "array"
+    });
+}

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

@@ -0,0 +1,58 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const upsertSnapshotQuery = "-- name: UpsertSnapshot :one\nINSERT INTO atc.event_snapshots (\n    tenant_id,\n    run_id,\n    sequence,\n    snapshot_type,\n    data\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5\n)\nON CONFLICT (tenant_id, run_id, snapshot_type)\nDO UPDATE\nSET\n    sequence = CASE\n        WHEN EXCLUDED.sequence > atc.event_snapshots.sequence THEN EXCLUDED.sequence\n        ELSE atc.event_snapshots.sequence\n    END,\n    data = CASE\n        WHEN EXCLUDED.sequence > atc.event_snapshots.sequence THEN EXCLUDED.data\n        ELSE atc.event_snapshots.data\n    END\nRETURNING tenant_id, run_id, sequence, snapshot_type, data, created_at";
+export interface UpsertSnapshotArgs {
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    snapshotType: string;
+    data: any;
+}
+export interface UpsertSnapshotRow {
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    snapshotType: string;
+    data: any;
+    createdAt: Date;
+}
+export declare function upsertSnapshot(client: Client, args: UpsertSnapshotArgs): Promise<UpsertSnapshotRow | null>;
+export declare const loadSnapshotQuery = "-- name: LoadSnapshot :one\nSELECT\n    tenant_id,\n    run_id,\n    sequence,\n    snapshot_type,\n    data,\n    created_at\nFROM atc.event_snapshots\nWHERE tenant_id = $1\n  AND run_id = $2\n  AND snapshot_type = $3";
+export interface LoadSnapshotArgs {
+    tenantId: string;
+    runId: string;
+    snapshotType: string;
+}
+export interface LoadSnapshotRow {
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    snapshotType: string;
+    data: any;
+    createdAt: Date;
+}
+export declare function loadSnapshot(client: Client, args: LoadSnapshotArgs): Promise<LoadSnapshotRow | null>;
+export declare const deleteSnapshotQuery = "-- name: DeleteSnapshot :exec\nDELETE FROM atc.event_snapshots\nWHERE tenant_id = $1\n  AND run_id = $2\n  AND snapshot_type = $3";
+export interface DeleteSnapshotArgs {
+    tenantId: string;
+    runId: string;
+    snapshotType: string;
+}
+export declare function deleteSnapshot(client: Client, args: DeleteSnapshotArgs): Promise<void>;
+export declare const listRunSnapshotsQuery = "-- name: ListRunSnapshots :many\nSELECT\n    tenant_id,\n    run_id,\n    sequence,\n    snapshot_type,\n    data,\n    created_at\nFROM atc.event_snapshots\nWHERE tenant_id = $1\n  AND run_id = $2\nORDER BY snapshot_type ASC";
+export interface ListRunSnapshotsArgs {
+    tenantId: string;
+    runId: string;
+}
+export interface ListRunSnapshotsRow {
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    snapshotType: string;
+    data: any;
+    createdAt: Date;
+}
+export declare function listRunSnapshots(client: Client, args: ListRunSnapshotsArgs): Promise<ListRunSnapshotsRow[]>;
+export {};