@multiagency/sdk 0.3.1

package/dist/compensation-contract.d.ts

@@ -0,0 +1,370 @@
+import { z } from "zod";
+export declare const requestId: z.ZodUUID;
+export declare const atomicUsdc: z.ZodString;
+export declare const compensationTerms: z.ZodObject<{
+    payee: z.ZodString;
+    title: z.ZodString;
+    document: z.ZodURL;
+    signedOn: z.ZodString;
+    start: z.ZodString;
+    end: z.ZodString;
+    ceiling: z.ZodString;
+    openingApproved: z.ZodString;
+    scope: z.ZodString;
+}, z.core.$strict>;
+export declare const compensationReport: z.ZodObject<{
+    agreementId: z.ZodUUID;
+    amount: z.ZodOptional<z.ZodString>;
+    start: z.ZodString;
+    end: z.ZodString;
+    contributions: z.ZodString;
+    assessment: z.ZodString;
+    evidence: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const paymentPreparation: z.ZodObject<{
+    type: z.ZodLiteral<"prepare">;
+    command: z.ZodObject<{
+        commandId: z.ZodUUID;
+        id: z.ZodUUID;
+        expectedVersion: z.ZodNumber;
+        mode: z.ZodEnum<{
+            isolated: "isolated";
+            shared: "shared";
+        }>;
+        until: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const agreementCommand: z.ZodObject<{
+    commandId: z.ZodUUID;
+    id: z.ZodUUID;
+    expectedVersion: z.ZodNumber;
+    terms: z.ZodObject<{
+        payee: z.ZodString;
+        title: z.ZodString;
+        document: z.ZodURL;
+        signedOn: z.ZodString;
+        start: z.ZodString;
+        end: z.ZodString;
+        ceiling: z.ZodString;
+        openingApproved: z.ZodString;
+        scope: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const reportCommand: z.ZodObject<{
+    commandId: z.ZodUUID;
+    id: z.ZodUUID;
+    expectedVersion: z.ZodNumber;
+    report: z.ZodObject<{
+        agreementId: z.ZodUUID;
+        amount: z.ZodOptional<z.ZodString>;
+        start: z.ZodString;
+        end: z.ZodString;
+        contributions: z.ZodString;
+        assessment: z.ZodString;
+        evidence: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>;
+    submit: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const reviewCommand: z.ZodObject<{
+    commandId: z.ZodUUID;
+    id: z.ZodUUID;
+    expectedVersion: z.ZodNumber;
+    decision: z.ZodEnum<{
+        approved: "approved";
+        changes_requested: "changes_requested";
+        declined: "declined";
+    }>;
+    feedback: z.ZodString;
+    approvedAmount: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CompensationTerms = z.infer<typeof compensationTerms>;
+export type CompensationReport = z.infer<typeof compensationReport>;
+export declare const agreementRecord: z.ZodObject<{
+    id: z.ZodUUID;
+    version: z.ZodNumber;
+    terms: z.ZodObject<{
+        payee: z.ZodString;
+        title: z.ZodString;
+        document: z.ZodURL;
+        signedOn: z.ZodString;
+        start: z.ZodString;
+        end: z.ZodString;
+        ceiling: z.ZodString;
+        openingApproved: z.ZodString;
+        scope: z.ZodString;
+    }, z.core.$strict>;
+    recordedBy: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strip>;
+export declare const requestRecord: z.ZodObject<{
+    id: z.ZodUUID;
+    version: z.ZodNumber;
+    payee: z.ZodString;
+    agreementVersion: z.ZodNumber;
+    report: z.ZodObject<{
+        agreementId: z.ZodUUID;
+        amount: z.ZodOptional<z.ZodString>;
+        start: z.ZodString;
+        end: z.ZodString;
+        contributions: z.ZodString;
+        assessment: z.ZodString;
+        evidence: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>;
+    state: z.ZodEnum<{
+        approved: "approved";
+        changes_requested: "changes_requested";
+        declined: "declined";
+        draft: "draft";
+        submitted: "submitted";
+    }>;
+    approvedAmount: z.ZodOptional<z.ZodString>;
+    feedback: z.ZodString;
+    reviewedBy: z.ZodNullable<z.ZodString>;
+    at: z.ZodString;
+    payment: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        mode: z.ZodEnum<{
+            isolated: "isolated";
+            shared: "shared";
+        }>;
+        id: z.ZodUUID;
+        until: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** The owner's explicitly approved amount: the only amount a payment of this request may carry. */
+export declare function approvedCompensation(request: CompensationRequest): string;
+export type CompensationAgreement = z.infer<typeof agreementRecord>;
+export type CompensationRequest = z.infer<typeof requestRecord>;
+export type CompensationView = {
+    agreements: (CompensationAgreement & {
+        approved: string;
+        remaining: string;
+    })[];
+    requests: CompensationRequest[];
+};
+export declare const compensationView: z.ZodObject<{
+    agreements: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        version: z.ZodNumber;
+        terms: z.ZodObject<{
+            payee: z.ZodString;
+            title: z.ZodString;
+            document: z.ZodURL;
+            signedOn: z.ZodString;
+            start: z.ZodString;
+            end: z.ZodString;
+            ceiling: z.ZodString;
+            openingApproved: z.ZodString;
+            scope: z.ZodString;
+        }, z.core.$strict>;
+        recordedBy: z.ZodString;
+        at: z.ZodString;
+        approved: z.ZodString;
+        remaining: z.ZodString;
+    }, z.core.$strip>>;
+    requests: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        version: z.ZodNumber;
+        payee: z.ZodString;
+        agreementVersion: z.ZodNumber;
+        report: z.ZodObject<{
+            agreementId: z.ZodUUID;
+            amount: z.ZodOptional<z.ZodString>;
+            start: z.ZodString;
+            end: z.ZodString;
+            contributions: z.ZodString;
+            assessment: z.ZodString;
+            evidence: z.ZodArray<z.ZodURL>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            approved: "approved";
+            changes_requested: "changes_requested";
+            declined: "declined";
+            draft: "draft";
+            submitted: "submitted";
+        }>;
+        approvedAmount: z.ZodOptional<z.ZodString>;
+        feedback: z.ZodString;
+        reviewedBy: z.ZodNullable<z.ZodString>;
+        at: z.ZodString;
+        payment: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            mode: z.ZodEnum<{
+                isolated: "isolated";
+                shared: "shared";
+            }>;
+            id: z.ZodUUID;
+            until: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ownerCompensationView: z.ZodObject<{
+    agreements: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        version: z.ZodNumber;
+        terms: z.ZodObject<{
+            payee: z.ZodString;
+            title: z.ZodString;
+            document: z.ZodURL;
+            signedOn: z.ZodString;
+            start: z.ZodString;
+            end: z.ZodString;
+            ceiling: z.ZodString;
+            openingApproved: z.ZodString;
+            scope: z.ZodString;
+        }, z.core.$strict>;
+        recordedBy: z.ZodString;
+        at: z.ZodString;
+        approved: z.ZodString;
+        remaining: z.ZodString;
+    }, z.core.$strip>>;
+    requests: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        version: z.ZodNumber;
+        payee: z.ZodString;
+        agreementVersion: z.ZodNumber;
+        report: z.ZodObject<{
+            agreementId: z.ZodUUID;
+            amount: z.ZodOptional<z.ZodString>;
+            start: z.ZodString;
+            end: z.ZodString;
+            contributions: z.ZodString;
+            assessment: z.ZodString;
+            evidence: z.ZodArray<z.ZodURL>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            approved: "approved";
+            changes_requested: "changes_requested";
+            declined: "declined";
+            draft: "draft";
+            submitted: "submitted";
+        }>;
+        approvedAmount: z.ZodOptional<z.ZodString>;
+        feedback: z.ZodString;
+        reviewedBy: z.ZodNullable<z.ZodString>;
+        at: z.ZodString;
+        payment: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            mode: z.ZodEnum<{
+                isolated: "isolated";
+                shared: "shared";
+            }>;
+            id: z.ZodUUID;
+            until: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    history: z.ZodArray<z.ZodObject<{
+        sequence: z.ZodNumber;
+        actor: z.ZodString;
+        record: z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodUUID;
+            version: z.ZodNumber;
+            payee: z.ZodString;
+            agreementVersion: z.ZodNumber;
+            report: z.ZodObject<{
+                agreementId: z.ZodUUID;
+                amount: z.ZodOptional<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+                contributions: z.ZodString;
+                assessment: z.ZodString;
+                evidence: z.ZodArray<z.ZodURL>;
+            }, z.core.$strict>;
+            state: z.ZodEnum<{
+                approved: "approved";
+                changes_requested: "changes_requested";
+                declined: "declined";
+                draft: "draft";
+                submitted: "submitted";
+            }>;
+            approvedAmount: z.ZodOptional<z.ZodString>;
+            feedback: z.ZodString;
+            reviewedBy: z.ZodNullable<z.ZodString>;
+            at: z.ZodString;
+            payment: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                mode: z.ZodEnum<{
+                    isolated: "isolated";
+                    shared: "shared";
+                }>;
+                id: z.ZodUUID;
+                until: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodUUID;
+            version: z.ZodNumber;
+            terms: z.ZodObject<{
+                payee: z.ZodString;
+                title: z.ZodString;
+                document: z.ZodURL;
+                signedOn: z.ZodString;
+                start: z.ZodString;
+                end: z.ZodString;
+                ceiling: z.ZodString;
+                openingApproved: z.ZodString;
+                scope: z.ZodString;
+            }, z.core.$strict>;
+            recordedBy: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+    payments: z.ZodArray<z.ZodObject<{
+        requestId: z.ZodUUID;
+        invoiceId: z.ZodString;
+        status: z.ZodString;
+        correlationId: z.ZodNullable<z.ZodString>;
+        refused: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const compensationCommand: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"list">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"agreement">;
+    command: z.ZodObject<{
+        commandId: z.ZodUUID;
+        id: z.ZodUUID;
+        expectedVersion: z.ZodNumber;
+        terms: z.ZodObject<{
+            payee: z.ZodString;
+            title: z.ZodString;
+            document: z.ZodURL;
+            signedOn: z.ZodString;
+            start: z.ZodString;
+            end: z.ZodString;
+            ceiling: z.ZodString;
+            openingApproved: z.ZodString;
+            scope: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"review">;
+    command: z.ZodObject<{
+        commandId: z.ZodUUID;
+        id: z.ZodUUID;
+        expectedVersion: z.ZodNumber;
+        decision: z.ZodEnum<{
+            approved: "approved";
+            changes_requested: "changes_requested";
+            declined: "declined";
+        }>;
+        feedback: z.ZodString;
+        approvedAmount: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"prepare">;
+    command: z.ZodObject<{
+        commandId: z.ZodUUID;
+        id: z.ZodUUID;
+        expectedVersion: z.ZodNumber;
+        mode: z.ZodEnum<{
+            isolated: "isolated";
+            shared: "shared";
+        }>;
+        until: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "type">;
+/** Owner send of a prepared shared payment, bound to the reviewed policy revision and digest. */
+export declare const compensationSend: z.ZodObject<{
+    type: z.ZodLiteral<"send">;
+    id: z.ZodUUID;
+    expectedPolicy: z.ZodObject<{
+        revision: z.ZodNumber;
+        digest: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;

package/dist/compensation-contract.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export const requestId = z.uuid();
+const account = z.string().regex(/^(?=.{2,64}$)([a-z\d]+[-_])*[a-z\d]+(\.([a-z\d]+[-_])*[a-z\d]+)*$/);
+export const atomicUsdc = z.string().regex(/^[1-9][0-9]{0,17}$/);
+const day = z.string().regex(/^\d{4}-\d{2}-\d{2}$/).refine(s => {
+    const date = new Date(`${s}T00:00:00Z`);
+    return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === s;
+}, "Enter a real calendar date");
+const https = z.url().max(1000).refine(s => { const u = new URL(s); return u.protocol === "https:" && !u.username && !u.password; }, "Use an HTTPS link without credentials");
+export const compensationTerms = z.object({
+    payee: account, title: z.string().trim().min(1).max(160), document: https,
+    signedOn: day, start: day, end: day, ceiling: atomicUsdc,
+    openingApproved: z.string().regex(/^(0|[1-9][0-9]{0,17})$/), scope: z.string().trim().max(2000),
+}).strict().refine(t => t.start <= t.end, "The period end must follow its start")
+    .refine(t => BigInt(t.openingApproved) <= BigInt(t.ceiling), "Previously approved compensation exceeds the ceiling");
+export const compensationReport = z.object({
+    agreementId: requestId, amount: atomicUsdc.optional(), start: day, end: day,
+    contributions: z.string().trim().min(1).max(4000), assessment: z.string().trim().min(1).max(2000),
+    evidence: z.array(https).max(12),
+}).strict().refine(t => t.start <= t.end, "The period end must follow its start")
+    .refine(t => new TextEncoder().encode(JSON.stringify(t)).length <= 12_000, "Keep the report and links within 12 KB");
+const mutation = { commandId: requestId, id: requestId, expectedVersion: z.number().int().nonnegative() };
+export const paymentPreparation = z.object({ type: z.literal("prepare"), command: z.object({ ...mutation, mode: z.enum(["shared", "isolated"]), until: z.iso.datetime().optional() }).strict().refine(c => c.mode !== "isolated" || !!c.until, "Choose the isolated order's payment deadline") }).strict();
+export const agreementCommand = z.object({ ...mutation, terms: compensationTerms }).strict();
+export const reportCommand = z.object({ ...mutation, report: compensationReport, submit: z.boolean() }).strict();
+export const reviewCommand = z.object({ ...mutation, decision: z.enum(["approved", "changes_requested", "declined"]), feedback: z.string().trim().max(2000), approvedAmount: atomicUsdc.optional() }).strict()
+    .refine(c => c.decision === "approved" || c.feedback.length > 0, "Explain the feedback or decline");
+export const agreementRecord = z.object({ id: requestId, version: z.number().int().positive(), terms: compensationTerms, recordedBy: z.string(), at: z.string() });
+export const requestRecord = z.object({
+    id: requestId, version: z.number().int().positive(), payee: account, agreementVersion: z.number().int().positive(),
+    report: compensationReport, state: z.enum(["draft", "submitted", "changes_requested", "approved", "declined"]),
+    approvedAmount: atomicUsdc.optional(),
+    feedback: z.string(), reviewedBy: z.string().nullable(), at: z.string(),
+    payment: z.object({ mode: z.enum(["shared", "isolated"]), id: requestId, until: z.iso.datetime().optional() }).nullable().default(null),
+});
+/** The owner's explicitly approved amount: the only amount a payment of this request may carry. */
+export function approvedCompensation(request) {
+    if (request.state !== "approved" || !request.approvedAmount)
+        throw new Error("Approved compensation evidence is missing; restore and review the original record.");
+    return request.approvedAmount;
+}
+export const compensationView = z.object({ agreements: z.array(agreementRecord.extend({ approved: z.string().regex(/^\d+$/), remaining: z.string().regex(/^\d+$/) })), requests: z.array(requestRecord) });
+export const ownerCompensationView = compensationView.extend({ history: z.array(z.object({ sequence: z.number(), actor: z.string(), record: z.union([requestRecord, agreementRecord]) })), payments: z.array(z.object({ requestId: z.uuid(), invoiceId: z.string(), status: z.string(), correlationId: z.string().nullable(), refused: z.string().nullable() })) });
+export const compensationCommand = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("list") }).strict(),
+    z.object({ type: z.literal("agreement"), command: agreementCommand }).strict(),
+    z.object({ type: z.literal("review"), command: reviewCommand }).strict(),
+    paymentPreparation,
+]);
+/** Owner send of a prepared shared payment, bound to the reviewed policy revision and digest. */
+export const compensationSend = z.object({ type: z.literal("send"), id: z.uuid(), expectedPolicy: z.object({ revision: z.number().int().nonnegative(), digest: z.string().regex(/^sha256:[0-9a-f]{64}$/) }) }).strict();

package/dist/contract/agent-connection.d.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+/**
+ * Agent connections: a user connects an external agent to their MultiAgency workspace with an explicit, fixed set of
+ * permitted actions, and can list or revoke it. One mechanism for every role; each role has its own principal and
+ * permission sets. The first set is a contractor's own compensation reports and their payment-status reads.
+ * A connection never carries every permission its user has.
+ */
+/** The payee role, as sent on the wire. Released 1.5.0 clients expect "supplier" and do not read it (no compatibility, by decision). */
+export declare const PAYEE_ROLE: "payee";
+export declare const AGENT_CONNECTION_ROLES: readonly ["payee"];
+/** The contractor-report set: read the account's own compensation records, submit its own reports. */
+export declare const PAYEE_REPORT_PERMISSIONS: readonly ["compensation.read", "compensation.submit"];
+export declare const agentConnectionPermission: z.ZodEnum<{
+    "compensation.read": "compensation.read";
+    "compensation.submit": "compensation.submit";
+}>;
+export type AgentConnectionPermission = z.infer<typeof agentConnectionPermission>;
+/** A connection as its user sees it. Never the secret or its hash. */
+export declare const agentConnection: z.ZodObject<{
+    id: z.ZodUUID;
+    label: z.ZodString;
+    role: z.ZodEnum<{
+        payee: "payee";
+    }>;
+    permissions: z.ZodArray<z.ZodEnum<{
+        "compensation.read": "compensation.read";
+        "compensation.submit": "compensation.submit";
+    }>>;
+    host: z.ZodString;
+    instance: z.ZodString;
+    account: z.ZodString;
+    agentId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    revoked: z.ZodBoolean;
+}, z.core.$strip>;
+export type AgentConnection = z.infer<typeof agentConnection>;
+export declare const agentConnectionIssue: z.ZodObject<{
+    label: z.ZodString;
+    ttlSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/** The token is shown once, at issue; only its hash is stored. */
+export declare const agentConnectionStarted: z.ZodObject<{
+    connection: z.ZodObject<{
+        id: z.ZodUUID;
+        label: z.ZodString;
+        role: z.ZodEnum<{
+            payee: "payee";
+        }>;
+        permissions: z.ZodArray<z.ZodEnum<{
+            "compensation.read": "compensation.read";
+            "compensation.submit": "compensation.submit";
+        }>>;
+        host: z.ZodString;
+        instance: z.ZodString;
+        account: z.ZodString;
+        agentId: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        revoked: z.ZodBoolean;
+    }, z.core.$strip>;
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare const agentConnectionList: z.ZodObject<{
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        label: z.ZodString;
+        role: z.ZodEnum<{
+            payee: "payee";
+        }>;
+        permissions: z.ZodArray<z.ZodEnum<{
+            "compensation.read": "compensation.read";
+            "compensation.submit": "compensation.submit";
+        }>>;
+        host: z.ZodString;
+        instance: z.ZodString;
+        account: z.ZodString;
+        agentId: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        revoked: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const agentConnectionRevoked: z.ZodObject<{
+    revoked: z.ZodLiteral<true>;
+}, z.core.$strip>;

package/dist/contract/agent-connection.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Agent connections: a user connects an external agent to their MultiAgency workspace with an explicit, fixed set of
+ * permitted actions, and can list or revoke it. One mechanism for every role; each role has its own principal and
+ * permission sets. The first set is a contractor's own compensation reports and their payment-status reads.
+ * A connection never carries every permission its user has.
+ */
+/** The payee role, as sent on the wire. Released 1.5.0 clients expect "supplier" and do not read it (no compatibility, by decision). */
+export const PAYEE_ROLE = "payee";
+export const AGENT_CONNECTION_ROLES = [PAYEE_ROLE];
+/** The contractor-report set: read the account's own compensation records, submit its own reports. */
+export const PAYEE_REPORT_PERMISSIONS = ["compensation.read", "compensation.submit"];
+export const agentConnectionPermission = z.enum(PAYEE_REPORT_PERMISSIONS);
+/** A connection as its user sees it. Never the secret or its hash. */
+export const agentConnection = z.object({
+    id: z.uuid(),
+    label: z.string().min(1).max(80),
+    role: z.enum(AGENT_CONNECTION_ROLES),
+    permissions: z.array(agentConnectionPermission).min(1),
+    /** What the connection is bound to: it is refused anywhere else. */
+    host: z.string().min(1),
+    instance: z.string().min(1),
+    account: z.string().min(2),
+    agentId: z.string().min(1),
+    createdAt: z.iso.datetime(),
+    expiresAt: z.iso.datetime(),
+    revoked: z.boolean(),
+});
+export const agentConnectionIssue = z.strictObject({
+    label: z.string().trim().min(1).max(80),
+    ttlSeconds: z.number().int().min(60).max(86_400).default(3_600),
+});
+/** The token is shown once, at issue; only its hash is stored. */
+export const agentConnectionStarted = z.object({ connection: agentConnection, token: z.string().regex(/^tac_[0-9a-f-]{36}\.[A-Za-z0-9_-]{43}$/) });
+export const agentConnectionList = z.object({ connections: z.array(agentConnection) });
+export const agentConnectionRevoked = z.object({ revoked: z.literal(true) });

package/dist/contract/app-access.d.ts

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { AppScope } from "./app-consent.js";
+import type { OwnerAction } from "./owner-inputs.js";
+/**
+ * What an app deployment may do through `/apps/v1`: the gateway enforces with these same definitions, and
+ * the app client is typed by them. Presenting never authorizes.
+ */
+/** Reads the app may make with `read` consent. Workflow records (agreements, invoices, work orders) stay out. */
+export declare const APP_READS: readonly ["instance", "overview", "policyHistory", "activity", "unresolved", "held", "ledger", "ledgerCsv", "owner/actions", "owner/pending", "owner/status", "paymentHistory", "paymentStatus"];
+/** Owner actions with `owner` consent: prepared here, completed only by the owner's own wallet signature at submit. */
+export declare const APP_OWNER: readonly ["owner/prepare", "owner/submit", "owner/status", "owner/pending", "owner/actions"];
+/**
+ * Payout requests with `payout` consent: each sent at most once under the app's `requestId`, within the owner-signed
+ * policy, and held for the owner's vote when the policy says so. `held` shows what waits for that vote. `deposit` gives a
+ * one-time address that credits USDC, or wNEAR, to the agent's confidential balance, so the app can fund it; it moves
+ * nothing out.
+ */
+export declare const APP_PAYOUT: readonly ["payouts/request", "payouts/status", "held", "deposit"];
+export type AppProcedure = (typeof APP_READS)[number] | (typeof APP_OWNER)[number] | (typeof APP_PAYOUT)[number];
+/** Whether consent scopes cover a procedure (the gateway also requires the owner's own access to it). */
+export declare const appScopesCover: (scopes: readonly AppScope[], path: string) => boolean;
+/** Whether a parsed owner action is one the app may prepare (signer `wallet` is checked separately). */
+export declare function appMayAsk(action: {
+    type: string;
+    payees?: readonly unknown[];
+}): boolean;
+type Of<T extends OwnerAction["type"]> = Extract<OwnerAction, {
+    type: T;
+}>;
+/** The owner actions an app may prepare, as types. The gateway's check (`appMayAsk`) is the authority. */
+export type AppOwnerAction = (Omit<Of<"agent_create">, "payees"> & {
+    owner: NonNullable<Of<"agent_create">["owner"]>;
+}) | Of<"agent_freeze"> | Of<"agent_unfreeze"> | Of<"grant_issue"> | Of<"grant_revoke"> | Of<"approval_vote"> | Of<"policy_update">;
+/**
+ * A NEP-366 owner action the platform holds for the owner to sign on its confirm page (`/confirm/<token>`). The link
+ * shows the action's terms to whoever holds it; the bytes to sign go only to whoever presents the owner's signature over
+ * the link's text, which the page asks the owner's wallet for. Open it for the owner right away: the intent expires in minutes. Follow the outcome with
+ * `owner/status`; the app can't submit it.
+ */
+export declare const appConfirm: z.ZodObject<{
+    url: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$loose>;
+/** `GET /apps/v1/agents/<agent>`: what the owner's consent must name. */
+export declare const appAgent: z.ZodObject<{
+    agent: z.ZodString;
+    owner: z.ZodString;
+    agentId: z.ZodNullable<z.ZodString>;
+    created: z.ZodBoolean;
+    host: z.ZodString;
+    deployment: z.ZodString;
+}, z.core.$loose>;
+/** A stored consent as the platform shows it: never its message, nonce or signature. Times are epoch milliseconds. */
+export declare const appConsentView: z.ZodObject<{
+    id: z.ZodString;
+    deployment: z.ZodString;
+    host: z.ZodString;
+    organization: z.ZodString;
+    owner: z.ZodString;
+    agent: z.ZodString;
+    agentId: z.ZodString;
+    scopes: z.ZodArray<z.ZodEnum<{
+        owner: "owner";
+        payout: "payout";
+        read: "read";
+    }>>;
+    expiresAt: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    publicKey: z.ZodString;
+    revoked: z.ZodBoolean;
+    revokedAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const appConsentList: z.ZodObject<{
+    consents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        deployment: z.ZodString;
+        host: z.ZodString;
+        organization: z.ZodString;
+        owner: z.ZodString;
+        agent: z.ZodString;
+        agentId: z.ZodString;
+        scopes: z.ZodArray<z.ZodEnum<{
+            owner: "owner";
+            payout: "payout";
+            read: "read";
+        }>>;
+        expiresAt: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        publicKey: z.ZodString;
+        revoked: z.ZodBoolean;
+        revokedAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const appConsentStored: z.ZodObject<{
+    consent: z.ZodObject<{
+        id: z.ZodString;
+        deployment: z.ZodString;
+        host: z.ZodString;
+        organization: z.ZodString;
+        owner: z.ZodString;
+        agent: z.ZodString;
+        agentId: z.ZodString;
+        scopes: z.ZodArray<z.ZodEnum<{
+            owner: "owner";
+            payout: "payout";
+            read: "read";
+        }>>;
+        expiresAt: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        publicKey: z.ZodString;
+        revoked: z.ZodBoolean;
+        revokedAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+/** `POST /apps/v1/setup`: the hosted agent's name and its setup consent (agent ID `unborn`). */
+export declare const appSetupStored: z.ZodObject<{
+    agent: z.ZodString;
+    consent: z.ZodObject<{
+        id: z.ZodString;
+        deployment: z.ZodString;
+        host: z.ZodString;
+        organization: z.ZodString;
+        owner: z.ZodString;
+        agent: z.ZodString;
+        agentId: z.ZodString;
+        scopes: z.ZodArray<z.ZodEnum<{
+            owner: "owner";
+            payout: "payout";
+            read: "read";
+        }>>;
+        expiresAt: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        publicKey: z.ZodString;
+        revoked: z.ZodBoolean;
+        revokedAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const appRevoked: z.ZodObject<{
+    revoked: z.ZodLiteral<true>;
+}, z.core.$loose>;
+export {};