@fourier-labs/harbour-contracts 0.69.0 → 0.71.0

package/dist/gen-ts/integration-execute-input-rules.js

@@ -4,25 +4,67 @@ export const IntegrationExecuteInputRules = {
     "slack.channel.history": {
         idempotencyKey: false,
         fields: {
-            limit: { kind: "integer", required: false, minimum: 1, maximum: 15, default: 15 },
+            limit: { kind: "integer", required: false, minimum: 1, maximum: 100, default: 15 },
+            cursor: { kind: "string", required: false, minLength: 1, maxLength: 256 },
+            oldest: { kind: "string", required: false, minLength: 1, maxLength: 64 },
+            latest: { kind: "string", required: false, minLength: 1, maxLength: 64 },
         },
     },
     "slack.message.post": {
         idempotencyKey: true,
         fields: {
             text: { kind: "string", required: true, minLength: 1, maxLength: 4000 },
+            threadId: { kind: "string", required: false, minLength: 0, pattern: "^[A-Za-z0-9._-]{1,64}$" },
+            format: { kind: "enum", required: false, values: ["plain", "mrkdwn"], default: "plain" },
+        },
+    },
+    "slack.message.update": {
+        idempotencyKey: false,
+        fields: {
+            messageId: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z0-9._-]{1,64}$" },
+            text: { kind: "string", required: true, minLength: 1, maxLength: 4000 },
+            format: { kind: "enum", required: false, values: ["plain", "mrkdwn"], default: "plain" },
+        },
+    },
+    "slack.message.delete": {
+        idempotencyKey: false,
+        fields: {
+            messageId: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z0-9._-]{1,64}$" },
+        },
+    },
+    "slack.dm.send": {
+        idempotencyKey: true,
+        fields: {
+            to: { kind: "string[]", required: true, minItems: 1, maxItems: 8, uniqueItems: true, item: { minLength: 3, maxLength: 254, pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$" } },
+            text: { kind: "string", required: true, minLength: 1, maxLength: 4000 },
+            format: { kind: "enum", required: false, values: ["plain", "mrkdwn"], default: "plain" },
+        },
+    },
+    "slack.user.lookup": {
+        idempotencyKey: false,
+        fields: {
+            email: { kind: "string", required: true, minLength: 3, maxLength: 254, pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$" },
         },
     },
     "gmail.thread.list": {
         idempotencyKey: false,
         fields: {
-            limit: { kind: "integer", required: false, minimum: 1, maximum: 15, default: 15 },
+            limit: { kind: "integer", required: false, minimum: 1, maximum: 50, default: 15 },
+            q: { kind: "string", required: false, minLength: 1, maxLength: 256 },
+            labelIds: { kind: "string[]", required: false, minItems: 1, maxItems: 5, uniqueItems: true, item: { minLength: 1, maxLength: 64 }, default: ["INBOX"] },
+            pageToken: { kind: "string", required: false, minLength: 1, maxLength: 256 },
+        },
+    },
+    "gmail.thread.read": {
+        idempotencyKey: false,
+        fields: {
+            threadId: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z0-9._-]{1,64}$" },
         },
     },
     "gmail.message.read": {
         idempotencyKey: false,
         fields: {
-            messageId: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z0-9_-]{1,64}$" },
+            messageId: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z0-9._-]{1,64}$" },
         },
     },
     "gmail.message.send": {
@@ -33,13 +75,41 @@ export const IntegrationExecuteInputRules = {
             bcc: { kind: "string[]", required: false, minItems: 1, maxItems: 50, uniqueItems: true, item: { minLength: 3, maxLength: 254, pattern: "^[^\\s@<>,;\"]+@[^\\s@<>,;\"]+\\.[^\\s@<>,;\"]+$" } },
             subject: { kind: "string", required: true, minLength: 1, maxLength: 256 },
             text: { kind: "string", required: true, minLength: 1, maxLength: 4000 },
+            html: { kind: "string", required: false, minLength: 1, maxLength: 65536 },
+            attachments: { kind: "object[]", required: false, minItems: 1, maxItems: 5, fields: {
+                    filename: { kind: "string", required: true, minLength: 1, maxLength: 255 },
+                    contentType: { kind: "string", required: true, minLength: 1, maxLength: 128 },
+                    dataBase64: { kind: "string", required: true, minLength: 1, maxLength: 2796203 },
+                } },
             replyToMessageId: { kind: "string", required: false, minLength: 0, pattern: "^[A-Za-z0-9_-]{1,64}$" },
         },
     },
+    "gmail.attachment.read": {
+        idempotencyKey: false,
+        fields: {
+            messageId: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z0-9._-]{1,64}$" },
+            attachmentId: { kind: "string", required: true, minLength: 1, maxLength: 512 },
+        },
+    },
     "warehouse.view.read": {
         idempotencyKey: false,
         fields: {
-            columns: { kind: "string[]", required: true, minItems: 1, maxItems: 32, uniqueItems: false, item: { minLength: 0, pattern: "^(?:\\*|[A-Za-z_][A-Za-z0-9_]{0,62})$" } },
+            columns: { kind: "string[]", required: false, minItems: 1, maxItems: 32, uniqueItems: false, item: { minLength: 0, pattern: "^(?:\\*|[A-Za-z_][A-Za-z0-9_]{0,62})$" } },
+            where: { kind: "object[]", required: false, minItems: 1, maxItems: 16, fields: {
+                    column: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z_][A-Za-z0-9_]{0,62}$" },
+                    op: { kind: "enum", required: true, values: ["eq", "ne", "gt", "gte", "lt", "lte", "in", "notIn", "isNull", "isNotNull"] },
+                    value: { kind: "value", required: false, types: ["string", "number", "boolean"], maxLength: 256, list: { minItems: 1, maxItems: 100, types: ["string", "number"] } },
+                } },
+            groupBy: { kind: "string[]", required: false, minItems: 1, maxItems: 8, uniqueItems: false, item: { minLength: 0, pattern: "^[A-Za-z_][A-Za-z0-9_]{0,62}$" } },
+            aggregates: { kind: "object[]", required: false, minItems: 1, maxItems: 16, fields: {
+                    fn: { kind: "enum", required: true, values: ["count", "sum", "avg", "min", "max"] },
+                    column: { kind: "string", required: true, minLength: 0, pattern: "^(?:\\*|[A-Za-z_][A-Za-z0-9_]{0,62})$" },
+                    as: { kind: "string", required: true, minLength: 0, pattern: "^[a-z_][a-z0-9_]{0,62}$" },
+                } },
+            orderBy: { kind: "object[]", required: false, minItems: 1, maxItems: 8, fields: {
+                    column: { kind: "string", required: true, minLength: 0, pattern: "^[A-Za-z_][A-Za-z0-9_]{0,62}$" },
+                    direction: { kind: "enum", required: false, values: ["asc", "desc"], default: "asc" },
+                } },
             limit: { kind: "integer", required: false, minimum: 1, maximum: 1000, default: 100 },
         },
     },
@@ -60,55 +130,113 @@ function matches(pattern, value) {
     }
     return compiled.test(value);
 }
+function refuse(field, message) { return { ok: false, problem: { field, message } }; }
+const valueNouns = { string: ['a string', 'strings'], number: ['a number', 'numbers'], boolean: ['a boolean', 'booleans'] };
+function either(parts) {
+    return parts.length > 1 ? `${parts.slice(0, -1).join(', ')} or ${parts[parts.length - 1]}` : parts.join('');
+}
+function isScalar(types, maxLength, value) {
+    if (typeof value === 'string')
+        return types.includes('string') && (maxLength === undefined || value.length <= maxLength);
+    if (typeof value === 'number')
+        return types.includes('number') && Number.isFinite(value);
+    return typeof value === 'boolean' && types.includes('boolean');
+}
 /**
- * Validates one operation's input against the contract and returns it with the
- * contract's defaults applied. The message names the field and its allowed
- * range; it is the sentence the platform answers with, so a caller may show it.
+ * Checks one object's fields in rule order and applies defaults: the input
+ * itself (where null counts as absent), or one entry of an object[] input
+ * (where only a missing key is absent, so null is refused like any wrong value).
  */
-export function validateIntegrationExecuteInput(operation, input) {
-    const rule = IntegrationExecuteInputRules[operation];
-    if (!rule)
-        return { ok: false, problem: { field: 'operation', message: `${operation} is not a declared integration operation` } };
-    const raw = input === undefined ? {} : input;
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
-        return { ok: false, problem: { field: 'input', message: 'input must be an object' } };
-    const given = raw;
+function checkFields(operation, prefix, fields, given, nullIsAbsent) {
     for (const name of Object.keys(given))
-        if (!Object.prototype.hasOwnProperty.call(rule.fields, name))
-            return { ok: false, problem: { field: name, message: `${name} is not an input of ${operation}` } };
+        if (!Object.prototype.hasOwnProperty.call(fields, name))
+            return refuse(prefix + name, `${prefix}${name} is not an input of ${operation}`);
     const out = {};
-    for (const [name, field] of Object.entries(rule.fields)) {
+    for (const [name, field] of Object.entries(fields)) {
+        const path = prefix + name;
         const value = given[name];
-        if (value === undefined || value === null) {
+        if (value === undefined || (nullIsAbsent && value === null)) {
             if (field.required)
-                return { ok: false, problem: { field: name, message: `${name} is required for ${operation}` } };
-            if (field.kind === 'integer' && field.default !== undefined)
+                return refuse(path, `${path} is required for ${operation}`);
+            if ((field.kind === 'integer' || field.kind === 'enum') && field.default !== undefined)
                 out[name] = field.default;
+            if (field.kind === 'string[]' && field.default !== undefined)
+                out[name] = [...field.default];
             continue;
         }
-        if (field.kind === 'integer') {
+        const checked = checkField(operation, path, name, field, value);
+        if (!checked.ok)
+            return checked;
+        out[name] = checked.value;
+    }
+    return { ok: true, value: out };
+}
+function checkField(operation, path, name, field, value) {
+    switch (field.kind) {
+        case 'integer':
             if (typeof value !== 'number' || !Number.isInteger(value) || value < field.minimum || value > field.maximum)
-                return { ok: false, problem: { field: name, message: `${name} must be an integer between ${field.minimum} and ${field.maximum}` } };
-        }
-        else if (field.kind === 'string') {
+                return refuse(path, `${path} must be an integer between ${field.minimum} and ${field.maximum}`);
+            return { ok: true, value };
+        case 'string':
             if (typeof value !== 'string' || value.length < field.minLength || (field.maxLength !== undefined && value.length > field.maxLength))
-                return { ok: false, problem: { field: name, message: field.maxLength !== undefined ? `${name} must be ${field.minLength} to ${field.maxLength} characters` : `${name} must be a string of at least ${field.minLength} characters` } };
+                return refuse(path, field.maxLength !== undefined ? `${path} must be ${field.minLength} to ${field.maxLength} characters` : `${path} must be a string of at least ${field.minLength} characters`);
             if (field.pattern && !matches(field.pattern, value))
-                return { ok: false, problem: { field: name, message: `${name} must match ${field.pattern}` } };
-        }
-        else {
+                return refuse(path, `${path} must match ${field.pattern}`);
+            return { ok: true, value };
+        case 'enum':
+            if (typeof value !== 'string' || !field.values.includes(value))
+                return refuse(path, `${path} must be one of ${field.values.join(', ')}`);
+            return { ok: true, value };
+        case 'string[]': {
             if (!Array.isArray(value) || value.length < field.minItems || value.length > field.maxItems)
-                return { ok: false, problem: { field: name, message: `${name} must list ${field.minItems} to ${field.maxItems} items` } };
+                return refuse(path, `${path} must list ${field.minItems} to ${field.maxItems} items`);
             const seen = new Set();
             for (const [index, item] of value.entries()) {
                 if (typeof item !== 'string' || item.length < field.item.minLength || (field.item.maxLength !== undefined && item.length > field.item.maxLength) || (field.item.pattern !== undefined && !matches(field.item.pattern, item)))
-                    return { ok: false, problem: { field: name, message: `${name}[${index}] is not a valid ${name} entry` } };
+                    return refuse(path, `${path}[${index}] is not a valid ${name} entry`);
                 if (field.uniqueItems && seen.has(item))
-                    return { ok: false, problem: { field: name, message: `${name} must not repeat an entry` } };
+                    return refuse(path, `${path} must not repeat an entry`);
                 seen.add(item);
             }
+            return { ok: true, value };
+        }
+        case 'object[]': {
+            if (!Array.isArray(value) || value.length < field.minItems || value.length > field.maxItems)
+                return refuse(path, `${path} must list ${field.minItems} to ${field.maxItems} items`);
+            const entries = [];
+            for (const [index, item] of value.entries()) {
+                if (item === null || typeof item !== 'object' || Array.isArray(item))
+                    return refuse(path, `${path}[${index}] is not a valid ${name} entry`);
+                const entry = checkFields(operation, `${path}[${index}].`, field.fields, item, false);
+                if (!entry.ok)
+                    return entry;
+                entries.push(entry.value);
+            }
+            return { ok: true, value: entries };
+        }
+        case 'value': {
+            const { types, maxLength, list } = field;
+            if (isScalar(types, maxLength, value) || (list !== undefined && Array.isArray(value) && value.length >= list.minItems && value.length <= list.maxItems && value.every(item => isScalar(list.types, maxLength, item))))
+                return { ok: true, value };
+            const shapes = types.map(type => (type === 'string' && maxLength !== undefined ? `a string of at most ${maxLength} characters` : valueNouns[type][0]));
+            if (list !== undefined)
+                shapes.push(`a list of ${list.minItems} to ${list.maxItems} ${either(list.types.map(type => valueNouns[type][1]))}`);
+            return refuse(path, `${path} must be ${either(shapes)}`);
         }
-        out[name] = value;
     }
-    return { ok: true, input: out };
+}
+/**
+ * Validates one operation's input against the contract and returns it with the
+ * contract's defaults applied. The message names the field and its allowed
+ * range; it is the sentence the platform answers with, so a caller may show it.
+ */
+export function validateIntegrationExecuteInput(operation, input) {
+    const rule = IntegrationExecuteInputRules[operation];
+    if (!rule)
+        return refuse('operation', `${operation} is not a declared integration operation`);
+    const raw = input === undefined ? {} : input;
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return refuse('input', 'input must be an object');
+    const checked = checkFields(operation, '', rule.fields, raw, true);
+    return checked.ok ? { ok: true, input: checked.value } : checked;
 }

package/dist/gen-ts/integration-execute-request.d.ts

@@ -1,5 +1,5 @@
 /**
- * Body of POST /_harbour/integrations/execute (app SDK), forwarded unchanged to the governance development and runtime execute routes. Exactly one declared operation against one declared resource. The identity mode is fixed by the operation for every operation but slack.message.post, and always enforced from an approved grant; any identity/userId/scope field is rejected by additionalProperties. A slack.message.post runs as the app (the IT-approved per-app name from the grant, plus a "Posted by <app> on Isomorph" footer) or as the signed-in person (no name, no footer) — the same input either way — and since 0.55.0 the call names which of the app's approved modes it runs under (`mode`): required when IT approved both modes for the app (MODE_REQUIRED otherwise), optional when it approved one (that one is used), and a named mode without an approved grant is refused (MODE_NOT_GRANTED) rather than served under the other, so approval order never decides what a post does. Per-operation input bounds: slack.channel.history {limit? 1..15, default 15}; slack.message.post {text 1..4000 chars} and a required idempotencyKey retained across retries of one explicit Send; gmail.thread.list {limit? 1..15, default 15}; gmail.message.read {messageId}; gmail.message.send {to 1..50 addresses (to+cc+bcc <= 50 in total), cc?, bcc?, subject 1..256 chars, text 1..4000 chars, replyToMessageId?} and a required idempotencyKey like slack.message.post (plain text only, no attachments); warehouse.view.read {columns 1..32, limit? 1..1000, default 100}. Each operation's then-block is the one statement of its input rules: propertyNames.enum names the fields it accepts, required the ones it needs, and per-field overrides (maximum, default) narrow the shared property. Codegen derives IntegrationExecuteInputRules and validateIntegrationExecuteInput (gen-ts/integration-execute-input-rules.ts, gen-go/integration_execute_input_rules.go) from exactly these blocks, so the governance execute route, the app SDK and the kit's local check refuse the same request with the same message. Transport limits (not expressible here): request <= 16 KiB, total deadline 10 s.
+ * Body of POST /_harbour/integrations/execute (app SDK), forwarded unchanged to the governance development and runtime execute routes. Exactly one declared operation against one declared resource. The identity mode is fixed by the operation for every operation but the declared-mode Slack operations (slack.channel.history, slack.message.post, slack.message.update, slack.message.delete; 0.71.0 widened history), and always enforced from an approved grant; any identity/userId/scope field is rejected by additionalProperties. A declared-mode operation runs as the app (for a post: the IT-approved per-app name from the grant, plus a "Posted by <app> on Isomorph" footer) or as the signed-in person (no name, no footer) — the same input either way — and since 0.55.0 the call names which of the app's approved modes it runs under (`mode`): required when IT approved both modes for the app (MODE_REQUIRED otherwise), optional when it approved one (that one is used), and a named mode without an approved grant is refused (MODE_NOT_GRANTED) rather than served under the other, so approval order never decides what a call does. Per-operation input bounds (0.71.0, ADR 0018): slack.channel.history {limit? 1..100, default 15, cursor?, oldest?, latest?}; slack.message.post {text 1..4000 chars, threadId?, format? plain|mrkdwn} and a required idempotencyKey retained across retries of one explicit Send; slack.message.update {messageId, text, format?}; slack.message.delete {messageId}; slack.dm.send {to 1..8 addresses, text, format?} (app mode only) with a required idempotencyKey; slack.user.lookup {email}; gmail.thread.list {limit? 1..50, default 15, q?, labelIds? default [INBOX], pageToken?}; gmail.thread.read {threadId}; gmail.message.read {messageId}; gmail.attachment.read {messageId, attachmentId}; gmail.message.send {to 1..50 addresses (to+cc+bcc <= 50 in total), cc?, bcc?, subject 1..256 chars, text 1..4000 chars, html? <= 64 KiB, attachments? 1..5 of <= 2 MiB each as base64, replyToMessageId?} and a required idempotencyKey like slack.message.post; warehouse.view.read {columns? 1..32, where? 1..16 filters, groupBy? 1..8 columns, aggregates? 1..16, orderBy? 1..8, limit? 1..1000, default 100} (0.70.0: a plain read names columns, an aggregate read names aggregates and optionally groupBy; the cross-field rules — exactly one of columns or aggregates, groupBy needs aggregates, a filter value that fits its op, orderBy naming a returned column, every named column approved — are enforced by governance, not expressible here; ADR 0017). Each operation's then-block is the one statement of its input rules: propertyNames.enum names the fields it accepts, required the ones it needs, and per-field overrides (maximum, default) narrow the shared property. Codegen derives IntegrationExecuteInputRules and validateIntegrationExecuteInput (gen-ts/integration-execute-input-rules.ts, gen-go/integration_execute_input_rules.go) from exactly these blocks, so the governance execute route, the app SDK and the kit's local check refuse the same request with the same message. Transport limits (not expressible here): request <= 16 KiB except a gmail.message.send carrying attachments (governance sizes that route for the attachment bound), total deadline 10 s.
  */
 export type IntegrationExecuteRequest = {
     /**
@@ -7,26 +7,69 @@ export type IntegrationExecuteRequest = {
      */
     connection: string;
     /**
-     * Closed operation set. Extending it is a contracts change. gmail.message.send (0.50.0) sends one plain-text email as the signed-in person: a send like slack.message.post (explicit Send, idempotencyKey, write receipt) under user identity. slack.message.post (0.53.0) runs in the mode the app declares: app (the company's Slack app, under the IT-approved per-app name) or user (the signed-in person, after their consent); since 0.55.0 each call names which of the approved modes it runs under.
+     * Closed operation set. Extending it is a contracts change. gmail.message.send (0.50.0) sends one email as the signed-in person: a send like slack.message.post (explicit Send, idempotencyKey, write receipt) under user identity; since 0.71.0 it may carry an HTML body and attachments. slack.message.post (0.53.0) runs in the mode the app declares: app (the company's Slack app, under the IT-approved per-app name) or user (the signed-in person, after their consent); since 0.55.0 each call names which of the approved modes it runs under. 0.71.0 (ADR 0018) adds slack.message.update and slack.message.delete (declared mode, like post), slack.dm.send (app mode: a direct message to 1..8 workspace members named by email), slack.user.lookup (app mode: email to Slack user id), gmail.thread.read (every message of one thread) and gmail.attachment.read (one attachment's bytes), and lets slack.channel.history run in app mode as well as user mode.
      */
-    operation: 'slack.channel.history' | 'slack.message.post' | 'gmail.thread.list' | 'gmail.message.read' | 'gmail.message.send' | 'warehouse.view.read';
+    operation: 'slack.channel.history' | 'slack.message.post' | 'slack.message.update' | 'slack.message.delete' | 'slack.dm.send' | 'slack.user.lookup' | 'gmail.thread.list' | 'gmail.thread.read' | 'gmail.message.read' | 'gmail.message.send' | 'gmail.attachment.read' | 'warehouse.view.read';
     /**
      * Tenant-wide logical alias of a connection (governance sourceId) or of a resource under it.
      */
     resource: string;
     input: {
         /**
-         * Read operations: how many items to return; the per-operation then-block sets the real ceiling (15 for slack.channel.history and gmail.thread.list, 1000 for warehouse.view.read) and the default.
+         * Read operations: how many items to return; the per-operation then-block sets the real ceiling (100 for slack.channel.history, 50 for gmail.thread.list, 1000 for warehouse.view.read) and the default.
          */
         limit?: number;
         /**
-         * slack.message.post / gmail.message.send: the plain-text body, 1..4000 characters.
+         * slack.message.post / slack.message.update / slack.dm.send / gmail.message.send: the body, 1..4000 characters (plain text, or Slack mrkdwn when `format` says so).
          */
         text?: string;
         /**
-         * gmail.message.read: the Gmail message id a gmail.thread.list result named.
+         * slack.message.post / slack.message.update / slack.dm.send (0.71.0): how Slack renders `text`; plain when absent.
+         */
+        format?: 'plain' | 'mrkdwn';
+        /**
+         * slack.message.post (0.71.0): the Slack message ts (a slack.channel.history message id) the post replies to, so it lands in that thread. gmail.thread.read: the Gmail thread id a gmail.thread.list result named.
+         */
+        threadId?: string;
+        /**
+         * gmail.message.read / gmail.attachment.read: the Gmail message id a gmail.thread.list or gmail.thread.read result named. slack.message.update / slack.message.delete (0.71.0): the Slack message ts a post or history result named.
          */
         messageId?: string;
+        /**
+         * gmail.attachment.read (0.71.0): the attachment id a gmail.message.read or gmail.thread.read result named.
+         */
+        attachmentId?: string;
+        /**
+         * slack.channel.history (0.71.0): the `nextCursor` of the previous page; absent reads the newest page.
+         */
+        cursor?: string;
+        /**
+         * slack.channel.history (0.71.0): only messages after this Slack ts.
+         */
+        oldest?: string;
+        /**
+         * slack.channel.history (0.71.0): only messages before this Slack ts.
+         */
+        latest?: string;
+        /**
+         * gmail.thread.list (0.71.0): a Gmail search query (the search-box syntax, e.g. `from:jane newer_than:7d`).
+         */
+        q?: string;
+        /**
+         * gmail.thread.list (0.71.0): the Gmail labels a thread must carry (all of them); INBOX when absent.
+         *
+         * @minItems 1
+         * @maxItems 5
+         */
+        labelIds?: string[];
+        /**
+         * gmail.thread.list (0.71.0): the `nextPageToken` of the previous page; absent reads the first page.
+         */
+        pageToken?: string;
+        /**
+         * slack.user.lookup (0.71.0): the workspace member's email address to resolve to a Slack user id.
+         */
+        email?: string;
         to?: EmailAddressList;
         cc?: EmailAddressList1;
         bcc?: EmailAddressList2;
@@ -39,19 +82,58 @@ export type IntegrationExecuteRequest = {
          */
         replyToMessageId?: string;
         /**
-         * Explicit columns, or `*` alone when the app's approved resource grant allows all current and future columns.
+         * gmail.message.send (0.71.0): an HTML body sent beside `text` (which stays the plain-text alternative), at most 64 KiB.
+         */
+        html?: string;
+        /**
+         * gmail.message.send (0.71.0): files to attach, 1..5, each at most 2 MiB (2,796,203 base64 characters).
+         *
+         * @minItems 1
+         * @maxItems 5
+         */
+        attachments?: EmailAttachment[];
+        /**
+         * warehouse.view.read, a plain read: explicit columns, or `*` alone when the app's approved resource grant allows all current and future columns. An aggregate read names aggregates instead.
          *
          * @minItems 1
          * @maxItems 32
          */
         columns?: string[];
+        /**
+         * warehouse.view.read (0.70.0): filters the warehouse applies before it returns, grouping or limits rows. All of them must hold (AND); there is no OR and no LIKE.
+         *
+         * @minItems 1
+         * @maxItems 16
+         */
+        where?: WarehouseFilter[];
+        /**
+         * warehouse.view.read (0.70.0): columns (never `*`) that group the rows; needs aggregates. Each returned row is one group: its groupBy columns, then its aggregate aliases.
+         *
+         * @minItems 1
+         * @maxItems 8
+         */
+        groupBy?: string[];
+        /**
+         * warehouse.view.read (0.70.0): what an aggregate read computes, over each group or over every matching row when there is no groupBy.
+         *
+         * @minItems 1
+         * @maxItems 16
+         */
+        aggregates?: WarehouseAggregate[];
+        /**
+         * warehouse.view.read (0.70.0): sort keys, first key first. Without orderBy an aggregate read is sorted by its groupBy columns and a plain read is not sorted at all.
+         *
+         * @minItems 1
+         * @maxItems 8
+         */
+        orderBy?: WarehouseOrder[];
     };
     /**
      * UUID of one explicit Send action; required for slack.message.post and gmail.message.send only. The same key with the same payload and subject returns the recorded outcome for seven days.
      */
     idempotencyKey?: string;
     /**
-     * slack.message.post only (0.55.0): which of the app's IT-approved modes this post runs under — app (the company's Slack app, under the grant's per-app name and the footer) or user (the signed-in person, after their consent; no name, no footer). Required when the app holds approved grants for both modes (else MODE_REQUIRED); may be omitted when it holds one, which is then used. A named mode without an approved grant is refused with MODE_NOT_GRANTED; governance never falls back to the other mode. Every other operation's mode is fixed, so the field is refused there.
+     * The declared-mode Slack operations only (slack.message.post since 0.55.0; slack.channel.history, slack.message.update and slack.message.delete since 0.71.0): which of the app's IT-approved modes this call runs under — app (the company's Slack app; a post goes out under the grant's per-app name and the footer) or user (the signed-in person, after their consent; no name, no footer). Required when the app holds approved grants for both modes (else MODE_REQUIRED); may be omitted when it holds one, which is then used. A named mode without an approved grant is refused with MODE_NOT_GRANTED; governance never falls back to the other mode. Every other operation's mode is fixed, so the field is refused there.
      */
     mode?: 'app' | 'user';
 };
@@ -60,7 +142,7 @@ export type IntegrationExecuteRequest = {
  */
 export type EmailAddress = string;
 /**
- * gmail.message.send: primary recipients.
+ * gmail.message.send: primary recipients. slack.dm.send (0.71.0): the workspace members to message, by email, 1..8; several open one group DM.
  *
  * @minItems 1
  * @maxItems 50
@@ -80,3 +162,70 @@ export type EmailAddressList1 = EmailAddress[];
  * @maxItems 50
  */
 export type EmailAddressList2 = EmailAddress[];
+/**
+ * A filter comparison: = <> > >= < <= IN, NOT IN, IS NULL, IS NOT NULL. Word-like so every value is a valid generated constant.
+ */
+export type WarehouseFilterOp = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'isNull' | 'isNotNull';
+/**
+ * An aggregate function.
+ */
+export type WarehouseAggregateFn = 'count' | 'sum' | 'avg' | 'min' | 'max';
+/**
+ * Sort direction; asc when absent.
+ */
+export type WarehouseOrderDirection = 'asc' | 'desc';
+/**
+ * One file attached to a gmail.message.send (0.71.0), carried inline as base64. At most 2 MiB of bytes, which is 2,796,203 base64 characters.
+ */
+export interface EmailAttachment {
+    /**
+     * The name the recipient sees.
+     */
+    filename: string;
+    /**
+     * The MIME type, e.g. application/pdf.
+     */
+    contentType: string;
+    /**
+     * The file bytes, standard base64.
+     */
+    dataBase64: string;
+}
+/**
+ * One warehouse.view.read filter (0.70.0): <column> <op> <value>. The value is always bound as a query parameter, never written into the SQL. Which value an op takes is a governance rule: isNull/isNotNull take none; in/notIn take a non-empty list of one scalar type; every other op takes one scalar, and a boolean only with eq/ne.
+ */
+export interface WarehouseFilter {
+    /**
+     * The filtered column; never `*`.
+     */
+    column: string;
+    op: WarehouseFilterOp;
+    /**
+     * The value compared with: a string (a date or timestamp is its ISO string), a number, a boolean, or a list of strings or numbers for in/notIn. Never null; use isNull or isNotNull.
+     */
+    value?: string | number | boolean | (string | number)[];
+}
+/**
+ * One computed column of an aggregate warehouse.view.read (0.70.0): fn(column) AS as. `*` is a column only for count (a governance rule). The value follows the read's cell rules, so a 64-bit or decimal result may be a string.
+ */
+export interface WarehouseAggregate {
+    fn: WarehouseAggregateFn;
+    /**
+     * A plain warehouse column identifier, or `*` as the sole selection when IT exposed all current and future columns.
+     */
+    column: string;
+    /**
+     * The name the computed value is returned under; unique in the read and never a groupBy column (governance rules).
+     */
+    as: string;
+}
+/**
+ * One warehouse.view.read sort key (0.70.0). A plain read sorts by a selected column (any column when it selects `*`); an aggregate read sorts by a groupBy column or an aggregate alias (governance rules).
+ */
+export interface WarehouseOrder {
+    /**
+     * A column or an aggregate alias; never `*`.
+     */
+    column: string;
+    direction?: WarehouseOrderDirection;
+}

package/dist/gen-ts/integration-execute-result.d.ts

@@ -1,17 +1,37 @@
 /**
- * The `data` member of a successful execute response `{data, requestId}`; the SDK unwraps `data`. Exactly one of the six operation results: slack.channel.history -> {messages, hasMore} (plain text/IDs/time, plus the display name and emoji icon a per-app-named app post carries — authorName/authorIcon, 0.55.0 — never the provider payload); slack.message.post -> {messageId}; gmail.thread.list -> {threads, hasMore} (newest inbox threads; each `messageId` is the thread's newest message, what gmail.message.read takes); gmail.message.read -> {id, threadId, subject, from, to, date, text, truncated} (headers plus the plain text with html stripped, cut at 16 KiB with `truncated` set); gmail.message.send -> {messageId, threadId} (the Gmail ids of the sent message and its thread); warehouse.view.read -> {rows} (decimal/64-bit values as strings, dates as ISO strings). An unknown send outcome is never a result; it is an error with details.code SEND_OUTCOME_UNKNOWN. Results over 1 MiB are rejected, not truncated.
+ * The `data` member of a successful execute response `{data, requestId}`; the SDK unwraps `data`. Exactly one of the operation results (twelve operations since 0.71.0, ADR 0018): slack.channel.history -> {messages, hasMore, nextCursor?} (plain text/IDs/time, plus the display name and emoji icon a per-app-named app post carries — authorName/authorIcon, 0.55.0 — never the provider payload; `nextCursor` when hasMore, to pass as the next read's `cursor`); slack.message.post, slack.message.update, slack.message.delete -> {messageId} (the Slack ts); slack.dm.send -> {messageId, channelId} (the ts and the DM channel it went to); slack.user.lookup -> {userId, displayName}; gmail.thread.list -> {threads, hasMore, nextPageToken?} (newest matching threads; each `messageId` is the thread's newest message, what gmail.message.read takes; `nextPageToken` when hasMore); gmail.thread.read -> {id, emails} (every message of the thread, oldest first, each shaped like a gmail.message.read result); gmail.message.read -> {id, threadId, subject, from, to, date, text, truncated, attachments?} (headers plus the plain text with html stripped, cut at 16 KiB with `truncated` set; `attachments` lists the files without their bytes, which gmail.attachment.read fetches by id); gmail.attachment.read -> {filename, mimeType, size, dataBase64}; gmail.message.send -> {messageId, threadId} (the Gmail ids of the sent message and its thread); warehouse.view.read -> {rows, truncated} (rows keyed by the selected columns, or for an aggregate read by the groupBy columns then the aggregate aliases; decimal/64-bit values as strings, dates as ISO strings; since 0.70.0 every server sends `truncated`, true when more rows matched than `limit` — the server reads limit+1 rows to know — so the rows are incomplete and must not be totalled or averaged; a server before 0.70.0 omitted it). An unknown send outcome is never a result; it is an error with details.code SEND_OUTCOME_UNKNOWN. A whole result over 1 MiB is rejected, never cut down to fit — except a gmail.attachment.read, whose single attachment is bounded by its own 2 MiB.
  */
 export type IntegrationExecuteResult = {
     /**
-     * @maxItems 15
+     * @maxItems 100
      */
     messages?: ChannelMessage[];
     hasMore?: boolean;
+    /**
+     * slack.channel.history (0.71.0): the cursor of the next (older) page, present only when hasMore.
+     */
+    nextCursor?: string;
     messageId?: string;
     /**
-     * @maxItems 15
+     * slack.dm.send (0.71.0): the Slack DM channel id the message went to.
+     */
+    channelId?: string;
+    /**
+     * slack.user.lookup (0.71.0): the Slack user id of the member with that email.
+     */
+    userId?: string;
+    /**
+     * slack.user.lookup (0.71.0): the member's display name, or real name when they set no display name; may be empty.
+     */
+    displayName?: string;
+    /**
+     * @maxItems 50
      */
     threads?: GmailThread[];
+    /**
+     * gmail.thread.list (0.71.0): the token of the next page, present only when hasMore.
+     */
+    nextPageToken?: string;
     id?: string;
     threadId?: string;
     subject?: string;
@@ -19,7 +39,32 @@ export type IntegrationExecuteResult = {
     to?: string;
     date?: string;
     text?: string;
+    /**
+     * gmail.message.read: the text was cut at 16 KiB. warehouse.view.read (0.70.0): more rows matched than the read's limit, so `rows` is incomplete.
+     */
     truncated?: boolean;
+    /**
+     * gmail.message.read (0.71.0): the message's attachments, without their bytes.
+     *
+     * @maxItems 100
+     */
+    attachments?: GmailAttachment[];
+    /**
+     * gmail.thread.read (0.71.0): every message of the thread, oldest first.
+     *
+     * @maxItems 100
+     */
+    emails?: GmailMessage[];
+    filename?: string;
+    mimeType?: string;
+    /**
+     * gmail.attachment.read (0.71.0): the attachment's size in bytes.
+     */
+    size?: number;
+    /**
+     * gmail.attachment.read (0.71.0): the attachment's bytes, standard base64, at most 2 MiB of bytes.
+     */
+    dataBase64?: string;
     /**
      * @maxItems 1000
      */
@@ -49,3 +94,32 @@ export interface GmailThread {
     date: string;
     snippet: string;
 }
+/**
+ * One attachment of a Gmail message (0.71.0), named without its bytes; gmail.attachment.read fetches them by `id`.
+ */
+export interface GmailAttachment {
+    id: string;
+    filename: string;
+    mimeType: string;
+    /**
+     * Bytes.
+     */
+    size: number;
+}
+/**
+ * One message of a gmail.thread.read result (0.71.0): the gmail.message.read shape.
+ */
+export interface GmailMessage {
+    id: string;
+    threadId: string;
+    subject: string;
+    from: string;
+    to: string;
+    date: string;
+    text: string;
+    truncated: boolean;
+    /**
+     * @maxItems 100
+     */
+    attachments?: GmailAttachment[];
+}