@trypattern/sdk 0.1.21 → 0.1.23

package/dist/components/ButtonBody.js

@@ -27,6 +27,7 @@ export function ButtonBody({ children, variant = 'primary', tone = variant === '
 const toneKeys = {
     neutral: 'Neutral',
     brand: 'Brand',
+    positive: 'Positive',
     danger: 'Danger'
 };
 const styles = stylex.create({
@@ -130,6 +131,10 @@ const looks = stylex.create({
         color: colors.onBrandSolidForeground,
         backgroundColor: colors.brandSolid
     },
+    primaryPositive: {
+        color: colors.onPositiveSolidForeground,
+        backgroundColor: colors.positiveSolid
+    },
     primaryDanger: {
         color: colors.onDangerSolidForeground,
         backgroundColor: colors.dangerSolid
@@ -144,6 +149,11 @@ const looks = stylex.create({
         backgroundColor: colors.componentOnContainerStrong,
         boxShadow: shadows.default
     },
+    secondaryPositive: {
+        color: colors.positiveForeground,
+        backgroundColor: colors.componentOnContainerStrong,
+        boxShadow: shadows.default
+    },
     secondaryDanger: {
         color: colors.dangerForeground,
         backgroundColor: colors.componentOnContainerStrong,
@@ -157,6 +167,10 @@ const looks = stylex.create({
         color: colors.onBrandSubtleForeground,
         backgroundColor: colors.brandSubtle
     },
+    tertiaryPositive: {
+        color: colors.onPositiveSubtleForeground,
+        backgroundColor: colors.positiveSubtle
+    },
     tertiaryDanger: {
         color: colors.dangerForeground,
         backgroundColor: colors.dangerSubtle
@@ -169,6 +183,10 @@ const looks = stylex.create({
         color: colors.brandForeground,
         backgroundColor: 'transparent'
     },
+    transparentPositive: {
+        color: colors.positiveForeground,
+        backgroundColor: 'transparent'
+    },
     transparentDanger: {
         color: colors.dangerForeground,
         backgroundColor: 'transparent'
@@ -189,6 +207,13 @@ const hovers = stylex.create({
             ':active': colors.brandSolidActive
         }
     },
+    primaryPositive: {
+        backgroundColor: {
+            default: colors.positiveSolid,
+            ':hover': colors.positiveSolidHover,
+            ':active': colors.positiveSolidHover
+        }
+    },
     primaryDanger: {
         backgroundColor: {
             default: colors.dangerSolid,
@@ -208,6 +233,12 @@ const hovers = stylex.create({
             ':hover': colors.componentOnContainerStrongHover
         }
     },
+    secondaryPositive: {
+        backgroundColor: {
+            default: colors.componentOnContainerStrong,
+            ':hover': colors.componentOnContainerStrongHover
+        }
+    },
     secondaryDanger: {
         backgroundColor: {
             default: colors.componentOnContainerStrong,
@@ -227,6 +258,12 @@ const hovers = stylex.create({
             ':hover': colors.brandSubtleHover
         }
     },
+    tertiaryPositive: {
+        backgroundColor: {
+            default: colors.positiveSubtle,
+            ':hover': colors.positiveSubtleHover
+        }
+    },
     tertiaryDanger: {
         backgroundColor: {
             default: colors.dangerSubtle,
@@ -250,6 +287,12 @@ const hovers = stylex.create({
             ':hover': colors.transparentHover
         }
     },
+    transparentPositive: {
+        backgroundColor: {
+            default: 'transparent',
+            ':hover': colors.positiveSubtleHover
+        }
+    },
     transparentDanger: {
         backgroundColor: {
             default: 'transparent',

package/dist/patternAccess.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 export declare const TABLES_READ = "tables:read";
 export declare const MEDIA_WRITE = "media:write";
+export declare const TABLES_WRITE = "tables:write";
 export declare const ASSERTION_SECONDS = 60;
 export declare const NEXT_PAGE_HEADER = "x-pattern-next";
 export declare const assertionKey: z.ZodObject<{
@@ -14,6 +15,7 @@ export type AssertionKey = z.output<typeof assertionKey>;
 declare const assertionScope: z.ZodEnum<{
     "tables:read": "tables:read";
     "media:write": "media:write";
+    "tables:write": "tables:write";
 }>;
 export type AssertionScope = z.output<typeof assertionScope>;
 export declare function signAssertion(key: AssertionKey, { sub, aud, scope }: {

package/dist/patternAccess.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 export const TABLES_READ = 'tables:read';
 export const MEDIA_WRITE = 'media:write';
+export const TABLES_WRITE = 'tables:write';
 export const ASSERTION_SECONDS = 60;
 export const NEXT_PAGE_HEADER = 'x-pattern-next';
 const CLOCK_SKEW_SECONDS = 30;
@@ -12,7 +13,7 @@ export const assertionKey = z.object({
     x: z.string(),
     d: z.string()
 });
-const assertionScope = z.enum([TABLES_READ, MEDIA_WRITE]);
+const assertionScope = z.enum([TABLES_READ, TABLES_WRITE, MEDIA_WRITE]);
 const assertionHeader = z.object({
     alg: z.literal('EdDSA'),
     typ: z.literal('JWT'),

package/dist/publishWire.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { appTitle } from './appTitle.ts';
 export { appTitle };
-export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signAssertion } from './patternAccess.ts';
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, TABLES_WRITE, assertionKey, signAssertion } from './patternAccess.ts';
 export type { AssertionKey, AssertionScope } from './patternAccess.ts';
 export declare const DASHBOARD_URL = "https://onpattern.app";
 export declare const APPS_DOMAIN = "onpattern.app";
@@ -320,6 +320,94 @@ export declare const databaseRows: z.ZodObject<{
     next: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type DatabaseRows = z.output<typeof databaseRows>;
+export declare const CHANGE_SET_ROWS = 300;
+export declare const dataChange: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"add">;
+    table: z.ZodString;
+    row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"update">;
+    table: z.ZodString;
+    id: z.ZodString;
+    before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"remove">;
+    table: z.ZodString;
+    id: z.ZodString;
+    before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "op">;
+export type DataChange = z.output<typeof dataChange>;
+export declare const changeOutcome: z.ZodObject<{
+    status: z.ZodEnum<{
+        failed: "failed";
+        applied: "applied";
+        skipped: "skipped";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+    row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ChangeOutcome = z.output<typeof changeOutcome>;
+export declare const changeReply: z.ZodObject<{
+    outcomes: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            failed: "failed";
+            applied: "applied";
+            skipped: "skipped";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const changeSetStatus: z.ZodEnum<{
+    declined: "declined";
+    waiting: "waiting";
+    applied: "applied";
+    expired: "expired";
+    undone: "undone";
+}>;
+export declare const changeSet: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        declined: "declined";
+        waiting: "waiting";
+        applied: "applied";
+        expired: "expired";
+        undone: "undone";
+    }>;
+    title: z.ZodString;
+    asked: z.ZodString;
+    device: z.ZodString;
+    createdAt: z.ZodString;
+    decidedAt: z.ZodNullable<z.ZodString>;
+    undoneAt: z.ZodNullable<z.ZodString>;
+    changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"add">;
+        table: z.ZodString;
+        row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"update">;
+        table: z.ZodString;
+        id: z.ZodString;
+        before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"remove">;
+        table: z.ZodString;
+        id: z.ZodString;
+        before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>], "op">>;
+    outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            failed: "failed";
+            applied: "applied";
+            skipped: "skipped";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ChangeSet = z.output<typeof changeSet>;
 export declare const publishServices: {
     readonly apps: {
         readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps", {}, z.ZodArray<z.ZodObject<{
@@ -647,6 +735,272 @@ export declare const publishServices: {
             next: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>>>;
     };
+    readonly changes: {
+        readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes", {}, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>>;
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly create: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes", {
+            asked: z.ZodString;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+        }, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly approve: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id/approve", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly decline: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id/decline", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        readonly undo: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/changes/:id/undo", {}, z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                declined: "declined";
+                waiting: "waiting";
+                applied: "applied";
+                expired: "expired";
+                undone: "undone";
+            }>;
+            title: z.ZodString;
+            asked: z.ZodString;
+            device: z.ZodString;
+            createdAt: z.ZodString;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            undoneAt: z.ZodNullable<z.ZodString>;
+            changes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"add">;
+                table: z.ZodString;
+                row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                after: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"remove">;
+                table: z.ZodString;
+                id: z.ZodString;
+                before: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>;
+            outcomes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    applied: "applied";
+                    skipped: "skipped";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                row: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    };
     readonly logins: {
         readonly read: NoInfer<import("./services.ts").ServiceCall<"/cli/logins/:approval", {}, z.ZodObject<{
             code: z.ZodString;

package/dist/publishWire.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { appTitle } from "./appTitle.js";
 export { appTitle };
-export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signAssertion } from "./patternAccess.js";
+export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, TABLES_WRITE, assertionKey, signAssertion } from "./patternAccess.js";
 import { call, defineServices } from "./services.js";
 export const DASHBOARD_URL = 'https://onpattern.app';
 export const APPS_DOMAIN = 'onpattern.app';
@@ -256,6 +256,50 @@ export const databaseRows = z.object({
     rows: z.array(databaseRow),
     next: z.string().nullable()
 });
+export const CHANGE_SET_ROWS = 300;
+const tableName = z.string().regex(/^[a-zA-Z][a-zA-Z0-9]*$/);
+const rowId = z.string().min(1).max(200);
+export const dataChange = z.discriminatedUnion('op', [
+    z.object({ op: z.literal('add'), table: tableName, row: databaseRow }),
+    z.object({
+        op: z.literal('update'),
+        table: tableName,
+        id: rowId,
+        before: databaseRow,
+        after: databaseRow
+    }),
+    z.object({
+        op: z.literal('remove'),
+        table: tableName,
+        id: rowId,
+        before: databaseRow
+    })
+]);
+export const changeOutcome = z.object({
+    status: z.enum(['applied', 'skipped', 'failed']),
+    reason: z.string().nullable(),
+    row: databaseRow.nullable()
+});
+export const changeReply = z.object({ outcomes: z.array(changeOutcome) });
+export const changeSetStatus = z.enum([
+    'waiting',
+    'applied',
+    'declined',
+    'expired',
+    'undone'
+]);
+export const changeSet = z.object({
+    id: z.string(),
+    status: changeSetStatus,
+    title: z.string(),
+    asked: z.string(),
+    device: z.string(),
+    createdAt: z.string(),
+    decidedAt: z.string().nullable(),
+    undoneAt: z.string().nullable(),
+    changes: z.array(dataChange),
+    outcomes: z.array(changeOutcome).nullable()
+});
 export const publishServices = defineServices({
     apps: {
         list: call({ get: '/apps', reply: z.array(appSummary) }),
@@ -332,6 +376,27 @@ export const publishServices = defineServices({
             reply: databaseRows
         })
     },
+    changes: {
+        list: call({ get: '/apps/:name/changes', reply: z.array(changeSet) }),
+        read: call({ get: '/apps/:name/changes/:id', reply: changeSet }),
+        create: call({
+            post: '/apps/:name/changes',
+            input: {
+                asked: z.string().trim().min(1).max(1000),
+                changes: z.array(dataChange).min(1).max(CHANGE_SET_ROWS)
+            },
+            reply: changeSet
+        }),
+        approve: call({
+            post: '/apps/:name/changes/:id/approve',
+            reply: changeSet
+        }),
+        decline: call({
+            post: '/apps/:name/changes/:id/decline',
+            reply: changeSet
+        }),
+        undo: call({ post: '/apps/:name/changes/:id/undo', reply: changeSet })
+    },
     logins: {
         read: call({ get: '/cli/logins/:approval', reply: loginToApprove }),
         approve: call({

package/dist/server/changes.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from 'hono';
+import type { Tables } from '../table.ts';
+import type { ServerEnv } from './env.ts';
+export declare function applyChanges<Group extends Tables>(c: Context<ServerEnv>, tables: Group): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 401, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 403, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    outcomes: {
+        status: "failed" | "applied" | "skipped";
+        reason: string | null;
+        row: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | null;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;