@anchrd/colab-sdk 0.0.0-stage → 0.1.0

package/dist/documents/documents.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { Instructions } from "../instructions/instructions.js";
+import { NodeId, NodePath, NodePerson, SecretFields } from "../nodes/nodes.js";
+import { IdempotencyKey, Rev } from "../primitives/primitives.js";
+// Documents (#39, Nodes › Dokument, E36, E59): the inputs of `intelligence_document_create`, `_get`
+// and `_update`, and their answer. A document is Markdown and is stored as Markdown, never as editor
+// JSON; a front matter at its top is part of the text. Every save is a version (#38) and sends the
+// node's `rev`.
+const DocumentId = NodeId.describe("The document's id, a `node_…` of kind document.");
+// The text of a document. Up to 1 MB in UTF-8 (`maxContentBytes` of #38).
+const Content = z
+    .string()
+    .describe("The whole document as Markdown, at most 1 MB in UTF-8. A front matter at the top stays as written. Images only by URL, links to other nodes in the text (`[Name](/n/node_…)`).");
+export const DocumentCreateInput = z.strictObject({
+    parentId: NodeId.describe("The folder to create the document in, one you can write to."),
+    name: z
+        .string()
+        .max(200)
+        .describe("The name as people read it. A name that starts with a dot hides it from listings. `INSTRUCTIONS` or `.INSTRUCTIONS` makes it the folder's INSTRUCTIONS; a folder holds at most one."),
+    // Required, and empty is a value: an empty document is created with an empty first version.
+    content: Content,
+    idempotencyKey: IdempotencyKey,
+});
+export const DocumentGetInput = z.strictObject({ documentId: DocumentId });
+export const DocumentUpdateInput = z.strictObject({
+    documentId: DocumentId,
+    content: Content,
+    rev: Rev,
+    editSession: z
+        .string()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("The editing session the editor keeps while a person stays on the document: saves of one session go into one version. Leaving it out makes every save a version of its own, which is right for an AI."),
+});
+export const DocumentDetail = z.strictObject({
+    documentId: DocumentId,
+    name: z.string(),
+    hidden: z.boolean(),
+    // Null at the top level of Shared, and where the caller cannot read the parent.
+    parentId: NodeId.nullable(),
+    path: NodePath,
+    content: z.string(),
+    // The current version's number, as people read it ("Version 6"); null for a document without one.
+    version: z.number().int().nullable(),
+    // When the current version was last saved into, and who began it; null without a version.
+    savedAt: z.iso.datetime().nullable(),
+    savedBy: NodePerson.nullable(),
+    // The OAuth client the current version was written through, null in the browser.
+    appHandle: z.string().nullable(),
+    // The state the next save sends (E70).
+    rev: z.number().int(),
+    archivedAt: z.iso.datetime().nullable(),
+    // Over MCP only, the INSTRUCTIONS of the document's folder (#39).
+    instructions: Instructions.optional(),
+    // A secret document (#357): `content` is empty while it is `locked` for this caller.
+    ...SecretFields,
+});

package/dist/error/error.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const errorCodes: readonly ["not_found", "invalid", "conflict", "unauthenticated", "unavailable"];
+export declare const ErrorCode: z.ZodEnum<{
+    unavailable: "unavailable";
+    not_found: "not_found";
+    invalid: "invalid";
+    conflict: "conflict";
+    unauthenticated: "unauthenticated";
+}>;
+export type ErrorCode = z.infer<typeof ErrorCode>;
+export declare const ErrorIssue: z.ZodObject<{
+    path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type ErrorIssue = z.infer<typeof ErrorIssue>;
+export declare const ErrorResponse: z.ZodObject<{
+    error: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        code: z.ZodLiteral<"invalid">;
+        message: z.ZodString;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            message: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        code: z.ZodEnum<{
+            unavailable: "unavailable";
+            not_found: "not_found";
+            conflict: "conflict";
+            unauthenticated: "unauthenticated";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>], "code">;
+}, z.core.$strict>;
+export type ErrorResponse = z.infer<typeof ErrorResponse>;

package/dist/error/error.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+// The one error shape of API and MCP (E68, E70). Missing rights answer `not_found`, never a code of
+// their own: a caller must not learn that something exists which it may not see.
+export const errorCodes = [
+    "not_found",
+    "invalid",
+    "conflict",
+    "unauthenticated",
+    "unavailable",
+];
+export const ErrorCode = z.enum(errorCodes);
+// One entry per rejected field: where, and a sentence why.
+export const ErrorIssue = z.strictObject({
+    path: z.array(z.union([z.string(), z.number()])),
+    message: z.string(),
+});
+// `issues` exists only next to `invalid`; on every other code a strict object rejects it.
+export const ErrorResponse = z.strictObject({
+    error: z.discriminatedUnion("code", [
+        z.strictObject({
+            code: z.literal("invalid"),
+            message: z.string(),
+            issues: z.array(ErrorIssue).optional(),
+        }),
+        z.strictObject({
+            code: ErrorCode.exclude(["invalid"]),
+            message: z.string(),
+        }),
+    ]),
+});

package/dist/events/events.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+export declare const EventId: z.ZodTemplateLiteral<`event_${string}`>;
+export declare const EventKind: z.ZodEnum<{
+    app: "app";
+    connector: "connector";
+    change: "change";
+    signin: "signin";
+}>;
+export type EventKind = z.infer<typeof EventKind>;
+export declare const ActorKind: z.ZodEnum<{
+    machine: "machine";
+    service: "service";
+    human: "human";
+}>;
+export type ActorKind = z.infer<typeof ActorKind>;
+export declare const EventListInput: z.ZodObject<{
+    actorId: z.ZodOptional<z.ZodUnion<readonly [z.ZodTemplateLiteral<`user_${string}`>, z.ZodTemplateLiteral<`service_${string}`>]>>;
+    actorKind: z.ZodOptional<z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>>;
+    userId: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
+    kind: z.ZodOptional<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodEnum<{
+        app: "app";
+        connector: "connector";
+        change: "change";
+        signin: "signin";
+    }>, z.ZodArray<z.ZodEnum<{
+        app: "app";
+        connector: "connector";
+        change: "change";
+        signin: "signin";
+    }>>]>, unknown>>;
+    search: z.ZodOptional<z.ZodString>;
+    failed: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+    from: z.ZodOptional<z.ZodISODateTime>;
+    to: z.ZodOptional<z.ZodISODateTime>;
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`event_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type EventListInput = z.infer<typeof EventListInput>;
+export declare const Event: z.ZodObject<{
+    eventId: z.ZodTemplateLiteral<`event_${string}`>;
+    createdAt: z.ZodISODateTime;
+    action: z.ZodString;
+    kind: z.ZodEnum<{
+        app: "app";
+        connector: "connector";
+        change: "change";
+        signin: "signin";
+    }>;
+    target: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    actor: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            service: "service";
+            human: "human";
+        }>>;
+        image: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    failed: z.ZodBoolean;
+    code: z.ZodNullable<z.ZodString>;
+    ip: z.ZodNullable<z.ZodString>;
+    detail: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type Event = z.infer<typeof Event>;
+export declare const EventList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodTemplateLiteral<`event_${string}`>;
+        createdAt: z.ZodISODateTime;
+        action: z.ZodString;
+        kind: z.ZodEnum<{
+            app: "app";
+            connector: "connector";
+            change: "change";
+            signin: "signin";
+        }>;
+        target: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        actor: z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                service: "service";
+                human: "human";
+            }>>;
+            image: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        failed: z.ZodBoolean;
+        code: z.ZodNullable<z.ZodString>;
+        ip: z.ZodNullable<z.ZodString>;
+        detail: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`event_${string}`>>;
+}, z.core.$strict>;
+export type EventList = z.infer<typeof EventList>;

package/dist/events/events.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Flag, Limit } from "../list-input.js";
+import { ServiceId } from "../services/services.js";
+import { UserId, UserKind } from "../users/users.js";
+// The protocol (Einstellungen › Protokoll, Nutzer › Person › Protokoll, #28): the input of
+// `access_event_list` and its answer. Only who may do what and who comes in; what happens to nodes
+// is not here.
+export const EventId = idSchema("event");
+// The filter "Art": changes to people, roles, services and connectors' settings, sign-ins (only the
+// failed ones are booked), connected apps and sessions, connectors.
+export const EventKind = z.enum(["change", "signin", "app", "connector"]);
+// Who did it: a person or a machine, or an outside service that declared its own interfaces under
+// `/auth/service` (#178).
+export const ActorKind = z.enum([...UserKind.options, "service"]);
+export const EventListInput = z.strictObject({
+    // Who did it: a user, or a service for what it declared itself (#178).
+    actorId: z.union([UserId, ServiceId]).optional(),
+    // What did it: a person or a machine. An event without an actor (a failed sign-in, what Colab does
+    // itself) is neither.
+    actorKind: UserKind.optional(),
+    // One person's protocol: the events this user did OR that were done to them.
+    userId: UserId.optional(),
+    // One kind or several (#125). Over REST one comma-separated value (`?kind=change,app`): a query
+    // string carries text.
+    kind: z
+        .preprocess((value) => (typeof value === "string" && value.includes(",") ? value.split(",") : value), z.union([EventKind, z.array(EventKind).min(1).max(EventKind.options.length)]))
+        .optional(),
+    // Part of the action, the target's or the actor's name, case-insensitive.
+    search: z.string().trim().min(1).max(200).optional(),
+    // Only the failed events, or only the others.
+    failed: Flag.optional(),
+    // The time range: `from` inclusive, `to` exclusive.
+    from: z.iso.datetime().optional(),
+    to: z.iso.datetime().optional(),
+    // The last event of the page before; the list runs newest first.
+    cursor: EventId.optional(),
+    limit: Limit.optional(),
+});
+export const Event = z.strictObject({
+    eventId: EventId,
+    createdAt: z.iso.datetime(),
+    // `resource.action`: `role.update`, `session.create` (a sign-in).
+    action: z.string(),
+    kind: EventKind,
+    // The name is the one at the time of the event: after a rename or a removal it is still the name
+    // the event was about.
+    target: z.strictObject({ id: z.string(), name: z.string().nullable() }).nullable(),
+    // Null for an anonymous attempt (a failed sign-in) and for what Colab does itself (a cleanup).
+    // Name and kind are null when the id no longer names anybody. `image` is the person's picture as
+    // `access.directory.resolve` gives it: null for a machine, a service and a person without one
+    // (#140). ⚠️ `userId` also carries a `service_…` id when `kind` is `service` (#178): the field
+    // keeps its name so the answer's shape stays as the UI reads it.
+    actor: z
+        .strictObject({
+        userId: z.string(),
+        name: z.string().nullable(),
+        kind: ActorKind.nullable(),
+        image: z.string().nullable(),
+    })
+        .nullable(),
+    failed: z.boolean(),
+    // The refusal's code, only next to `failed`.
+    code: z.string().nullable(),
+    // Only on a failed sign-in, and only for 90 days.
+    ip: z.string().nullable(),
+    detail: z.record(z.string(), z.unknown()).nullable(),
+});
+export const EventList = z.strictObject({ items: z.array(Event), nextCursor: EventId.nullable() });

package/dist/files/files.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export declare const FileId: z.ZodTemplateLiteral<`node_${string}`>;
+export type FileId = z.infer<typeof FileId>;
+export declare const maxFileBytes: number;
+export type FileFormat = "pdf" | "image" | "presentation" | "spreadsheet" | "word" | "code";
+export declare const fileFormatExtensions: Record<FileFormat, readonly string[]>;
+export declare function fileFormatOf(name: string): FileFormat | null;
+export declare const uploadTicketHeader = "x-colab-upload-ticket";
+export declare const uploadTicketLifetimeMs: number;
+export declare const FileCreateInput: z.ZodObject<{
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    name: z.ZodString;
+    mediaType: z.ZodString;
+    size: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type FileCreateInput = z.infer<typeof FileCreateInput>;
+export declare const FileUpdateInput: z.ZodObject<{
+    fileId: z.ZodTemplateLiteral<`node_${string}`>;
+    name: z.ZodString;
+    mediaType: z.ZodString;
+    size: z.ZodNumber;
+    rev: z.ZodNumber;
+}, z.core.$strict>;
+export type FileUpdateInput = z.infer<typeof FileUpdateInput>;
+export declare const FileGetInput: z.ZodObject<{
+    fileId: z.ZodTemplateLiteral<`node_${string}`>;
+}, z.core.$strict>;
+export type FileGetInput = z.infer<typeof FileGetInput>;
+export declare const UploadTicket: z.ZodObject<{
+    url: z.ZodURL;
+    ticket: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+    curl: z.ZodString;
+}, z.core.$strict>;
+export type UploadTicket = z.infer<typeof UploadTicket>;
+export declare const FileUpload: z.ZodObject<{
+    upload: z.ZodObject<{
+        url: z.ZodURL;
+        ticket: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+        curl: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type FileUpload = z.infer<typeof FileUpload>;
+export declare const FileDetail: z.ZodObject<{
+    fileId: z.ZodTemplateLiteral<`node_${string}`>;
+    name: z.ZodString;
+    fileName: z.ZodString;
+    mediaType: z.ZodString;
+    size: z.ZodNumber;
+    version: z.ZodObject<{
+        versionId: z.ZodTemplateLiteral<`version_${string}`>;
+        number: z.ZodNumber;
+    }, z.core.$strict>;
+    rev: z.ZodNumber;
+    text: z.ZodNullable<z.ZodString>;
+    contentUrl: z.ZodURL;
+}, z.core.$strict>;
+export type FileDetail = z.infer<typeof FileDetail>;

package/dist/files/files.js

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { NodeId } from "../nodes/nodes.js";
+import { IdempotencyKey, Rev } from "../primitives/primitives.js";
+import { VersionId } from "../versions/versions.js";
+// Files (#41, Nodes › Datei, E47): the inputs of `intelligence_file_create`, `_get` and `_update`,
+// the upload ticket they answer with, and what a file reads as. The bytes never travel through these
+// schemas: `_create` and `_update` hand out a short-lived ticket, and the bytes go to the upload door
+// with it, from a browser or a `curl` alike, so they never pass through an AI's context.
+// A file node's id, `node_…`: a file is a node like every other kind.
+export const FileId = idSchema("node").describe("The file's id, `node_…`.");
+// The largest file Colab takes (E47): 100 MB, in bytes. ⚠️ Decimal like every size the UI shows
+// ("3 kB", "1.2 MB"): with 100 MiB a file shown as "103 MB" was taken and one of 106 MB refused (#253).
+export const maxFileBytes = 100 * 1000 * 1000;
+export const fileFormatExtensions = {
+    pdf: ["pdf"],
+    image: ["png", "jpg", "jpeg", "gif", "webp", "avif", "bmp", "svg"],
+    presentation: ["pptx"],
+    spreadsheet: ["xlsx"],
+    word: ["docx"],
+    code: [
+        "txt",
+        "md",
+        "markdown",
+        "yaml",
+        "yml",
+        "json",
+        "csv",
+        "tsv",
+        "xml",
+        "html",
+        "css",
+        "js",
+        "mjs",
+        "ts",
+        "tsx",
+        "jsx",
+        "py",
+        "rb",
+        "go",
+        "rs",
+        "java",
+        "kt",
+        "swift",
+        "c",
+        "h",
+        "cpp",
+        "cs",
+        "php",
+        "sh",
+        "sql",
+        "toml",
+        "ini",
+        "env",
+        "log",
+    ],
+};
+// A file's format by the extension of its name, without regard to case; null for an unknown
+// extension and for a name without one.
+export function fileFormatOf(name) {
+    const extension = name.includes(".") ? (name.toLowerCase().split(".").at(-1) ?? "") : "";
+    for (const [format, known] of Object.entries(fileFormatExtensions)) {
+        if (known.includes(extension))
+            return format;
+    }
+    return null;
+}
+// The header the upload door reads the ticket from. ⚠️ A header and never a query parameter: a
+// ticket is a credential, and a query string lands in every proxy and edge log on the way.
+export const uploadTicketHeader = "x-colab-upload-ticket";
+// How long a ticket opens the door, from the moment it is issued.
+export const uploadTicketLifetimeMs = 15 * 60 * 1000;
+// What the uploader's client says the bytes are, `type/subtype` without parameters.
+const MediaType = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .regex(/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/, {
+    error: "A media type is written type/subtype, like application/pdf or image/png.",
+})
+    .max(160)
+    .describe("The file's media type, like application/pdf, image/png or text/csv. It decides how the file is shown and whether its text is read for search and AI.");
+const Size = z
+    .number()
+    .int()
+    .min(1)
+    .max(maxFileBytes, {
+    error: `A file can be at most ${maxFileBytes} bytes (100 MB).`,
+})
+    .describe(`The file's size in bytes, at most ${maxFileBytes} (100 MB). The upload is refused when its body is longer than this.`);
+const FileName = z
+    .string()
+    .max(200)
+    .describe("The file's name with its extension, like Preisliste.pdf. It is the name the download carries; on a new file it is also the node's name.");
+export const FileCreateInput = z.strictObject({
+    // ⚠️ Required and nullable (trap C015): null is the top level of Shared, like a folder.
+    parentId: NodeId.nullable().describe("The folder to put the file in, one you can write to; null puts it on the top level of Shared, visible to you until you share it."),
+    name: FileName,
+    mediaType: MediaType,
+    size: Size,
+    idempotencyKey: IdempotencyKey,
+});
+export const FileUpdateInput = z.strictObject({
+    fileId: FileId.describe("The file to upload a new version of."),
+    name: FileName,
+    mediaType: MediaType,
+    size: Size,
+    rev: Rev,
+});
+export const FileGetInput = z.strictObject({ fileId: FileId });
+// What `_create` and `_update` answer: the door, the ticket and the whole command. ⚠️ `ticket` is a
+// credential, and it is in this answer on purpose: it opens ONE upload for ONE person for fifteen
+// minutes. It appears nowhere else, never in an error and never in a log.
+export const UploadTicket = z.strictObject({
+    url: z.url(),
+    ticket: z.string().min(1),
+    expiresAt: z.iso.datetime(),
+    // A shell command that sends the file; the path to the file is the one placeholder left.
+    curl: z.string().min(1),
+});
+export const FileUpload = z.strictObject({ upload: UploadTicket });
+// A file as `_get` and the upload door answer it, always about its current version.
+export const FileDetail = z.strictObject({
+    fileId: FileId,
+    // The node's name, as the tree shows it.
+    name: z.string(),
+    // The name of the current version's file, the one a download carries.
+    fileName: z.string(),
+    mediaType: z.string(),
+    size: z.number().int(),
+    version: z.strictObject({ versionId: VersionId, number: z.number().int() }),
+    // The node's revision, to send with the next `_update`.
+    rev: z.number().int(),
+    // The text read from the current version for search and AI; null while it is being read, and for
+    // a file without text (an image, a ZIP).
+    text: z.string().nullable(),
+    // Where the bytes are read, with a session or a token and the right to read the file.
+    contentUrl: z.url(),
+});

package/dist/functions/functions.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const ServiceInterfaceFunctionCreateInput: z.ZodObject<{
+    serviceId: z.ZodTemplateLiteral<`service_${string}`>;
+    interfaceId: z.ZodTemplateLiteral<`interface_${string}`>;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type ServiceInterfaceFunctionCreateInput = z.infer<typeof ServiceInterfaceFunctionCreateInput>;
+export declare const ServiceInterfaceFunctionUpdateInput: z.ZodObject<{
+    serviceId: z.ZodTemplateLiteral<`service_${string}`>;
+    interfaceId: z.ZodTemplateLiteral<`interface_${string}`>;
+    functionId: z.ZodTemplateLiteral<`function_${string}`>;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type ServiceInterfaceFunctionUpdateInput = z.infer<typeof ServiceInterfaceFunctionUpdateInput>;
+export declare const ServiceInterfaceFunctionRemoveInput: z.ZodObject<{
+    serviceId: z.ZodTemplateLiteral<`service_${string}`>;
+    interfaceId: z.ZodTemplateLiteral<`interface_${string}`>;
+    functionId: z.ZodTemplateLiteral<`function_${string}`>;
+}, z.core.$strict>;
+export type ServiceInterfaceFunctionRemoveInput = z.infer<typeof ServiceInterfaceFunctionRemoveInput>;
+export declare const FunctionRemoved: z.ZodObject<{
+    functionId: z.ZodTemplateLiteral<`function_${string}`>;
+    name: z.ZodString;
+    permissions: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type FunctionRemoved = z.infer<typeof FunctionRemoved>;

package/dist/functions/functions.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { FunctionId, InterfaceId, RightWord, ServiceId } from "../services/services.js";
+// The functions of an outside service's interface (#26). A function is the last word of a right:
+// `datawarehouse / reports / read`.
+export const ServiceInterfaceFunctionCreateInput = z.strictObject({
+    serviceId: ServiceId,
+    interfaceId: InterfaceId,
+    name: RightWord,
+});
+// Renames the function and its rights in every role, in one step; a name the interface already
+// carries is `conflict`.
+export const ServiceInterfaceFunctionUpdateInput = z.strictObject({
+    serviceId: ServiceId,
+    interfaceId: InterfaceId,
+    functionId: FunctionId,
+    name: RightWord,
+});
+export const ServiceInterfaceFunctionRemoveInput = z.strictObject({
+    serviceId: ServiceId,
+    interfaceId: InterfaceId,
+    functionId: FunctionId,
+});
+// What fell with a removed function: the rights the roles held on it.
+export const FunctionRemoved = z.strictObject({
+    functionId: FunctionId,
+    name: z.string(),
+    permissions: z.array(z.string()),
+});

package/dist/grammar/grammar.d.ts

@@ -0,0 +1,62 @@
+export declare const packages: readonly ["intelligence", "access", "connectors", "documentation", "mail", "operator"];
+export declare const resources: {
+    readonly node: "nodes";
+    readonly folder: "folders";
+    readonly document: "documents";
+    readonly table: "tables";
+    readonly board: "boards";
+    readonly task: "tasks";
+    readonly dashboard: "dashboards";
+    readonly file: "files";
+    readonly run: "runs";
+    readonly version: "versions";
+    readonly chat: "chats";
+    readonly message: "messages";
+    readonly action: "actions";
+    readonly grant: "grants";
+    readonly link: "links";
+    readonly user: "users";
+    readonly role: "roles";
+    readonly machine: "machines";
+    readonly app: "apps";
+    readonly session: "sessions";
+    readonly service: "services";
+    readonly interface: "interfaces";
+    readonly function: "functions";
+    readonly invitation: "invitations";
+    readonly connector: "connectors";
+    readonly connection: "connections";
+    readonly call: "calls";
+    readonly event: "events";
+    readonly page: "pages";
+    readonly credential: "credentials";
+    readonly sso: "sso";
+    readonly secret: "secrets";
+};
+export declare const actions: readonly ["list", "get", "create", "update", "archive", "restore", "purge"];
+export declare const verbs: readonly ["invite", "resend", "disable", "enable", "rotate", "share", "move", "start", "complete", "test", "revoke", "remove", "unlock"];
+export type Package = (typeof packages)[number];
+export type Resource = keyof typeof resources;
+export type Action = (typeof actions)[number] | (typeof verbs)[number];
+export type ToolName = {
+    package: Package;
+    resources: readonly Resource[];
+    action: Action;
+};
+export type Route = {
+    method: "GET" | "POST" | "PATCH" | "DELETE";
+    path: string;
+};
+export declare function isPackage(word: string): word is Package;
+export declare function isAction(word: string): word is Action;
+export declare function isWord(word: string): boolean;
+export declare function parseConnectorFunction(key: string): {
+    resources: string[];
+    action: Action;
+};
+export declare function hasRoute(name: string): boolean;
+export declare function parseToolName(name: string): ToolName;
+export declare function toolRoute(name: string): Route;
+export declare function toolPermission(name: string): string;
+export declare function toolEvent(name: string): string;
+export declare function toolSchemaName(name: string): string;