@slates/test 1.0.0-rc.27 → 1.0.0-rc.28

package/dist/index.cjs

@@ -20,10 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  authenticateSlateTriggerGroupWebhookDelivery: () => authenticateSlateTriggerGroupWebhookDelivery,
   connectSlateTriggerGroupGateway: () => connectSlateTriggerGroupGateway,
   createLocalSlateTestClient: () => createLocalSlateTestClient,
   createSlatesTestClient: () => createSlatesTestClient,
   describeMcpCompatibleToolSchemas: () => describeMcpCompatibleToolSchemas,
+  expandSlateTriggerGroupWebhook: () => expandSlateTriggerGroupWebhook,
   expectMcpCompatibleToolSchema: () => expectMcpCompatibleToolSchema,
   expectSlateContract: () => expectSlateContract,
   expectSlateError: () => expectSlateError,
@@ -38,6 +40,7 @@ __export(index_exports, {
   processSlateTriggerGroupWebhook: () => processSlateTriggerGroupWebhook,
   receiveSlateTriggerGroupGatewayFrames: () => receiveSlateTriggerGroupGatewayFrames,
   registerSlateTriggerGroupWebhook: () => registerSlateTriggerGroupWebhook,
+  renewSlateTriggerGroupWebhook: () => renewSlateTriggerGroupWebhook,
   unregisterSlateTriggerGroupWebhook: () => unregisterSlateTriggerGroupWebhook,
   withSlateProfile: () => withSlateProfile
 });
@@ -255,17 +258,24 @@ var expectSlateContract = async (d) => {
   }
   return contract;
 };
-var registerSlateTriggerGroupWebhook = async (d) => d.client.registerTriggerGroupWebhook({
-  triggerGroupId: d.triggerGroupId,
-  webhookTargetIdentifier: d.webhookTargetIdentifier,
-  webhookTargetPayload: d.webhookTargetPayload,
-  webhookUrl: d.webhookUrl
-});
+var registerSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.registerTriggerGroupWebhook(input);
+};
+var renewSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.renewTriggerGroupWebhook(input);
+};
+var expandSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.expandTriggerGroupWebhook(input);
+};
 var pollSlateTriggerGroupEvents = async (d) => {
   d.client.ensureSession();
   return d.client.pollTriggerGroup({
     triggerGroupId: d.triggerGroupId,
-    state: d.state ?? null
+    state: d.state ?? null,
+    selection: d.selection
   });
 };
 var connectSlateTriggerGroupGateway = async (d) => {
@@ -292,6 +302,14 @@ var processSlateTriggerGroupWebhook = async (d) => d.client.processTriggerGroupW
   body: d.body,
   webhookRegistrationPayload: d.webhookRegistrationPayload ?? null
 });
+var authenticateSlateTriggerGroupWebhookDelivery = async (d) => d.client.authenticateTriggerGroupWebhookDelivery({
+  triggerGroupId: d.triggerGroupId,
+  url: d.url,
+  method: d.method ?? "POST",
+  headers: d.headers,
+  body: d.body,
+  deliveryConfig: d.deliveryConfig
+});
 var unregisterSlateTriggerGroupWebhook = async (d) => d.client.unregisterTriggerGroupWebhook({
   triggerGroupId: d.triggerGroupId,
   webhookRegistrationIdentifier: d.webhookRegistrationIdentifier,
@@ -14885,10 +14903,12 @@ var describeMcpCompatibleToolSchemas = (name, source) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  authenticateSlateTriggerGroupWebhookDelivery,
   connectSlateTriggerGroupGateway,
   createLocalSlateTestClient,
   createSlatesTestClient,
   describeMcpCompatibleToolSchemas,
+  expandSlateTriggerGroupWebhook,
   expectMcpCompatibleToolSchema,
   expectSlateContract,
   expectSlateError,
@@ -14903,6 +14923,7 @@ var describeMcpCompatibleToolSchemas = (name, source) => {
   processSlateTriggerGroupWebhook,
   receiveSlateTriggerGroupGatewayFrames,
   registerSlateTriggerGroupWebhook,
+  renewSlateTriggerGroupWebhook,
   unregisterSlateTriggerGroupWebhook,
   withSlateProfile
 });

package/dist/index.d.cts

@@ -246,14 +246,22 @@ declare let getSlateContract: (client: SlatesTestClient) => Promise<{
             type: "webhook";
             registration: {
                 mode: "auto";
+                deliveryConfig?: {
+                    userConfigSchema: Record<string, any>;
+                    fullConfigSchema: Record<string, any>;
+                } | undefined;
             } | {
                 mode: "manual";
                 userConfigSchema: Record<string, any>;
                 fullConfigSchema: Record<string, any>;
             };
+            supportsExpansion?: boolean | undefined;
+            supportsRenewal?: boolean | undefined;
+            reconcileIntervalSeconds?: number | undefined;
         };
         description?: string | undefined;
         metadata?: Record<string, any> | undefined;
+        selectionSchema?: Record<string, any> | undefined;
     }[];
     authMethods: {
         id: string;
@@ -445,14 +453,22 @@ declare let expectSlateContract: (d: {
             type: "webhook";
             registration: {
                 mode: "auto";
+                deliveryConfig?: {
+                    userConfigSchema: Record<string, any>;
+                    fullConfigSchema: Record<string, any>;
+                } | undefined;
             } | {
                 mode: "manual";
                 userConfigSchema: Record<string, any>;
                 fullConfigSchema: Record<string, any>;
             };
+            supportsExpansion?: boolean | undefined;
+            supportsRenewal?: boolean | undefined;
+            reconcileIntervalSeconds?: number | undefined;
         };
         description?: string | undefined;
         metadata?: Record<string, any> | undefined;
+        selectionSchema?: Record<string, any> | undefined;
     }[];
     authMethods: {
         id: string;
@@ -495,13 +511,87 @@ declare let expectSlateContract: (d: {
 }>;
 declare let registerSlateTriggerGroupWebhook: (d: {
     client: SlatesTestClient;
-    triggerGroupId: string;
-    webhookTargetIdentifier: string;
-    webhookTargetPayload: any;
-    webhookUrl: string;
-}) => Promise<{
+} & Parameters<SlatesTestClient["registerTriggerGroupWebhook"]>[0]) => Promise<{
+    webhookRegistrationIdentifier: string;
+    webhookRegistrationPayload: any;
+    expiresAt?: string | null | undefined;
+    renewAfter?: string | null | undefined;
+    routingKeys?: string[] | undefined;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+declare let renewSlateTriggerGroupWebhook: (d: {
+    client: SlatesTestClient;
+} & Parameters<SlatesTestClient["renewTriggerGroupWebhook"]>[0]) => Promise<{
     webhookRegistrationIdentifier: string;
     webhookRegistrationPayload: any;
+    expiresAt?: string | null | undefined;
+    renewAfter?: string | null | undefined;
+    routingKeys?: string[] | undefined;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+declare let expandSlateTriggerGroupWebhook: (d: {
+    client: SlatesTestClient;
+} & Parameters<SlatesTestClient["expandTriggerGroupWebhook"]>[0]) => Promise<{
+    events: {
+        payload: Record<string, any>;
+        triggerIds: string[];
+        idempotencyKey?: string | undefined;
+    }[];
+    updatedState?: any;
     requestTraces?: {
         startedAt: string;
         durationMs: number;
@@ -535,6 +625,7 @@ declare let pollSlateTriggerGroupEvents: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
     state?: any;
+    selection?: Record<string, any>;
 }) => Promise<{
     events: {
         payload: Record<string, any>;
@@ -678,6 +769,7 @@ declare let processSlateTriggerGroupWebhook: (d: {
         triggerIds: string[];
         idempotencyKey?: string | undefined;
     }[];
+    requiresExpansion?: boolean | undefined;
     response?: {
         status: number;
         headers: Record<string, string>;
@@ -718,6 +810,48 @@ declare let processSlateTriggerGroupWebhook: (d: {
         } | undefined;
     }[] | undefined;
 }>;
+declare let authenticateSlateTriggerGroupWebhookDelivery: (d: {
+    client: SlatesTestClient;
+    triggerGroupId: string;
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array | null;
+    deliveryConfig: unknown;
+}) => Promise<{
+    routingKeys: string[];
+    rejected?: {
+        status: number;
+    } | null | undefined;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
 declare let unregisterSlateTriggerGroupWebhook: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
@@ -805,4 +939,4 @@ declare let getMcpCompatibleToolSchemaCases: (source: ToolSchemaSource) => Reado
 declare let expectMcpCompatibleToolSchema: (tool: ToolSchemaTarget) => void;
 declare let describeMcpCompatibleToolSchemas: (name: string, source: ToolSchemaSource) => void;
 
-export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };
+export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, authenticateSlateTriggerGroupWebhookDelivery, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expandSlateTriggerGroupWebhook, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, renewSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };

package/dist/index.d.ts

@@ -246,14 +246,22 @@ declare let getSlateContract: (client: SlatesTestClient) => Promise<{
             type: "webhook";
             registration: {
                 mode: "auto";
+                deliveryConfig?: {
+                    userConfigSchema: Record<string, any>;
+                    fullConfigSchema: Record<string, any>;
+                } | undefined;
             } | {
                 mode: "manual";
                 userConfigSchema: Record<string, any>;
                 fullConfigSchema: Record<string, any>;
             };
+            supportsExpansion?: boolean | undefined;
+            supportsRenewal?: boolean | undefined;
+            reconcileIntervalSeconds?: number | undefined;
         };
         description?: string | undefined;
         metadata?: Record<string, any> | undefined;
+        selectionSchema?: Record<string, any> | undefined;
     }[];
     authMethods: {
         id: string;
@@ -445,14 +453,22 @@ declare let expectSlateContract: (d: {
             type: "webhook";
             registration: {
                 mode: "auto";
+                deliveryConfig?: {
+                    userConfigSchema: Record<string, any>;
+                    fullConfigSchema: Record<string, any>;
+                } | undefined;
             } | {
                 mode: "manual";
                 userConfigSchema: Record<string, any>;
                 fullConfigSchema: Record<string, any>;
             };
+            supportsExpansion?: boolean | undefined;
+            supportsRenewal?: boolean | undefined;
+            reconcileIntervalSeconds?: number | undefined;
         };
         description?: string | undefined;
         metadata?: Record<string, any> | undefined;
+        selectionSchema?: Record<string, any> | undefined;
     }[];
     authMethods: {
         id: string;
@@ -495,13 +511,87 @@ declare let expectSlateContract: (d: {
 }>;
 declare let registerSlateTriggerGroupWebhook: (d: {
     client: SlatesTestClient;
-    triggerGroupId: string;
-    webhookTargetIdentifier: string;
-    webhookTargetPayload: any;
-    webhookUrl: string;
-}) => Promise<{
+} & Parameters<SlatesTestClient["registerTriggerGroupWebhook"]>[0]) => Promise<{
+    webhookRegistrationIdentifier: string;
+    webhookRegistrationPayload: any;
+    expiresAt?: string | null | undefined;
+    renewAfter?: string | null | undefined;
+    routingKeys?: string[] | undefined;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+declare let renewSlateTriggerGroupWebhook: (d: {
+    client: SlatesTestClient;
+} & Parameters<SlatesTestClient["renewTriggerGroupWebhook"]>[0]) => Promise<{
     webhookRegistrationIdentifier: string;
     webhookRegistrationPayload: any;
+    expiresAt?: string | null | undefined;
+    renewAfter?: string | null | undefined;
+    routingKeys?: string[] | undefined;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
+declare let expandSlateTriggerGroupWebhook: (d: {
+    client: SlatesTestClient;
+} & Parameters<SlatesTestClient["expandTriggerGroupWebhook"]>[0]) => Promise<{
+    events: {
+        payload: Record<string, any>;
+        triggerIds: string[];
+        idempotencyKey?: string | undefined;
+    }[];
+    updatedState?: any;
     requestTraces?: {
         startedAt: string;
         durationMs: number;
@@ -535,6 +625,7 @@ declare let pollSlateTriggerGroupEvents: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
     state?: any;
+    selection?: Record<string, any>;
 }) => Promise<{
     events: {
         payload: Record<string, any>;
@@ -678,6 +769,7 @@ declare let processSlateTriggerGroupWebhook: (d: {
         triggerIds: string[];
         idempotencyKey?: string | undefined;
     }[];
+    requiresExpansion?: boolean | undefined;
     response?: {
         status: number;
         headers: Record<string, string>;
@@ -718,6 +810,48 @@ declare let processSlateTriggerGroupWebhook: (d: {
         } | undefined;
     }[] | undefined;
 }>;
+declare let authenticateSlateTriggerGroupWebhookDelivery: (d: {
+    client: SlatesTestClient;
+    triggerGroupId: string;
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array | null;
+    deliveryConfig: unknown;
+}) => Promise<{
+    routingKeys: string[];
+    rejected?: {
+        status: number;
+    } | null | undefined;
+    requestTraces?: {
+        startedAt: string;
+        durationMs: number;
+        request: {
+            method: string;
+            url: string;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        };
+        response?: {
+            status: number;
+            statusText?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            body?: {
+                text: string;
+                contentType?: string | undefined;
+                truncated?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        error?: {
+            message: string;
+            code?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;
 declare let unregisterSlateTriggerGroupWebhook: (d: {
     client: SlatesTestClient;
     triggerGroupId: string;
@@ -805,4 +939,4 @@ declare let getMcpCompatibleToolSchemaCases: (source: ToolSchemaSource) => Reado
 declare let expectMcpCompatibleToolSchema: (tool: ToolSchemaTarget) => void;
 declare let describeMcpCompatibleToolSchemas: (name: string, source: ToolSchemaSource) => void;
 
-export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };
+export { type ExpectedSlateAction, type ExpectedSlateTriggerGroup, type SlatesRuntimeContext, type SlatesTestClient, authenticateSlateTriggerGroupWebhookDelivery, connectSlateTriggerGroupGateway, createLocalSlateTestClient, createSlatesTestClient, describeMcpCompatibleToolSchemas, expandSlateTriggerGroupWebhook, expectMcpCompatibleToolSchema, expectSlateContract, expectSlateError, expectToolCall, getMcpCompatibleToolSchemaCases, getSlateContract, getVitestExpect, loadSlatesProfile, loadSlatesRuntimeContext, mapSlateTriggerEvent, pollSlateTriggerGroupEvents, processSlateTriggerGroupWebhook, receiveSlateTriggerGroupGatewayFrames, registerSlateTriggerGroupWebhook, renewSlateTriggerGroupWebhook, unregisterSlateTriggerGroupWebhook, withSlateProfile };

package/dist/index.module.js

@@ -223,17 +223,24 @@ var expectSlateContract = async (d) => {
   }
   return contract;
 };
-var registerSlateTriggerGroupWebhook = async (d) => d.client.registerTriggerGroupWebhook({
-  triggerGroupId: d.triggerGroupId,
-  webhookTargetIdentifier: d.webhookTargetIdentifier,
-  webhookTargetPayload: d.webhookTargetPayload,
-  webhookUrl: d.webhookUrl
-});
+var registerSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.registerTriggerGroupWebhook(input);
+};
+var renewSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.renewTriggerGroupWebhook(input);
+};
+var expandSlateTriggerGroupWebhook = async (d) => {
+  let { client, ...input } = d;
+  return client.expandTriggerGroupWebhook(input);
+};
 var pollSlateTriggerGroupEvents = async (d) => {
   d.client.ensureSession();
   return d.client.pollTriggerGroup({
     triggerGroupId: d.triggerGroupId,
-    state: d.state ?? null
+    state: d.state ?? null,
+    selection: d.selection
   });
 };
 var connectSlateTriggerGroupGateway = async (d) => {
@@ -260,6 +267,14 @@ var processSlateTriggerGroupWebhook = async (d) => d.client.processTriggerGroupW
   body: d.body,
   webhookRegistrationPayload: d.webhookRegistrationPayload ?? null
 });
+var authenticateSlateTriggerGroupWebhookDelivery = async (d) => d.client.authenticateTriggerGroupWebhookDelivery({
+  triggerGroupId: d.triggerGroupId,
+  url: d.url,
+  method: d.method ?? "POST",
+  headers: d.headers,
+  body: d.body,
+  deliveryConfig: d.deliveryConfig
+});
 var unregisterSlateTriggerGroupWebhook = async (d) => d.client.unregisterTriggerGroupWebhook({
   triggerGroupId: d.triggerGroupId,
   webhookRegistrationIdentifier: d.webhookRegistrationIdentifier,
@@ -14852,10 +14867,12 @@ var describeMcpCompatibleToolSchemas = (name, source) => {
   });
 };
 export {
+  authenticateSlateTriggerGroupWebhookDelivery,
   connectSlateTriggerGroupGateway,
   createLocalSlateTestClient,
   createSlatesTestClient,
   describeMcpCompatibleToolSchemas,
+  expandSlateTriggerGroupWebhook,
   expectMcpCompatibleToolSchema,
   expectSlateContract,
   expectSlateError,
@@ -14870,6 +14887,7 @@ export {
   processSlateTriggerGroupWebhook,
   receiveSlateTriggerGroupGatewayFrames,
   registerSlateTriggerGroupWebhook,
+  renewSlateTriggerGroupWebhook,
   unregisterSlateTriggerGroupWebhook,
   withSlateProfile
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/test",
-  "version": "1.0.0-rc.27",
+  "version": "1.0.0-rc.28",
   "publishConfig": {
     "access": "public"
   },
@@ -40,11 +40,11 @@
   },
   "dependencies": {
     "@lowerdeck/testing-tools": "latest",
-    "@slates/client": "1.0.0-rc.32",
-    "@slates/profiles": "1.0.0-rc.28"
+    "@slates/client": "1.0.0-rc.33",
+    "@slates/profiles": "1.0.0-rc.29"
   },
   "devDependencies": {
-    "@slates/provider": "1.0.0-rc.33",
+    "@slates/provider": "1.0.0-rc.34",
     "@slates/tsconfig": "1.0.0-rc.1",
     "typescript": "5.8.2",
     "vitest": "^3.1.2",

package/src/runtime.ts

@@ -352,29 +352,42 @@ export let expectSlateContract = async (d: {
   return contract;
 };
 
-export let registerSlateTriggerGroupWebhook = async (d: {
-  client: SlatesTestClient;
-  triggerGroupId: string;
-  webhookTargetIdentifier: string;
-  webhookTargetPayload: any;
-  webhookUrl: string;
-}) =>
-  d.client.registerTriggerGroupWebhook({
-    triggerGroupId: d.triggerGroupId,
-    webhookTargetIdentifier: d.webhookTargetIdentifier,
-    webhookTargetPayload: d.webhookTargetPayload,
-    webhookUrl: d.webhookUrl
-  });
+export let registerSlateTriggerGroupWebhook = async (
+  d: { client: SlatesTestClient } & Parameters<
+    SlatesTestClient['registerTriggerGroupWebhook']
+  >[0]
+) => {
+  let { client, ...input } = d;
+  return client.registerTriggerGroupWebhook(input);
+};
+
+export let renewSlateTriggerGroupWebhook = async (
+  d: { client: SlatesTestClient } & Parameters<SlatesTestClient['renewTriggerGroupWebhook']>[0]
+) => {
+  let { client, ...input } = d;
+  return client.renewTriggerGroupWebhook(input);
+};
+
+export let expandSlateTriggerGroupWebhook = async (
+  d: { client: SlatesTestClient } & Parameters<
+    SlatesTestClient['expandTriggerGroupWebhook']
+  >[0]
+) => {
+  let { client, ...input } = d;
+  return client.expandTriggerGroupWebhook(input);
+};
 
 export let pollSlateTriggerGroupEvents = async (d: {
   client: SlatesTestClient;
   triggerGroupId: string;
   state?: any;
+  selection?: Record<string, any>;
 }) => {
   d.client.ensureSession();
   return d.client.pollTriggerGroup({
     triggerGroupId: d.triggerGroupId,
-    state: d.state ?? null
+    state: d.state ?? null,
+    selection: d.selection
   });
 };
 
@@ -424,6 +437,24 @@ export let processSlateTriggerGroupWebhook = async (d: {
     webhookRegistrationPayload: d.webhookRegistrationPayload ?? null
   });
 
+export let authenticateSlateTriggerGroupWebhookDelivery = async (d: {
+  client: SlatesTestClient;
+  triggerGroupId: string;
+  url: string;
+  method?: string;
+  headers?: Record<string, string>;
+  body?: string | Uint8Array | null;
+  deliveryConfig: unknown;
+}) =>
+  d.client.authenticateTriggerGroupWebhookDelivery({
+    triggerGroupId: d.triggerGroupId,
+    url: d.url,
+    method: d.method ?? 'POST',
+    headers: d.headers,
+    body: d.body,
+    deliveryConfig: d.deliveryConfig
+  });
+
 export let unregisterSlateTriggerGroupWebhook = async (d: {
   client: SlatesTestClient;
   triggerGroupId: string;

package/src/triggerLifecycle.test.ts

@@ -0,0 +1,561 @@
+import {
+  Slate,
+  SlateAuth,
+  SlateConfig,
+  SlateSpecification,
+  SlateTrigger,
+  triggerGroup
+} from '@slates/provider';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import {
+  authenticateSlateTriggerGroupWebhookDelivery,
+  createLocalSlateTestClient,
+  expandSlateTriggerGroupWebhook,
+  pollSlateTriggerGroupEvents,
+  processSlateTriggerGroupWebhook,
+  registerSlateTriggerGroupWebhook,
+  renewSlateTriggerGroupWebhook
+} from './index';
+
+let fixture = (
+  options: {
+    selection?: 'required' | 'default';
+    legacy?: boolean;
+    expiresAt?: string | null;
+    renewAfter?: string | null;
+    invalidExpansion?: boolean;
+    reconcileIntervalSeconds?: number;
+    deliveryConfig?: boolean;
+  } = {}
+) => {
+  let contexts: { operation: string; auth: unknown; config: unknown; input: any }[] = [];
+  let auth = SlateAuth.create<{ token: string }>()
+    .output(z.object({ token: z.string() }))
+    .addTokenAuth({
+      type: 'auth.token',
+      key: 'token',
+      name: 'Token',
+      inputSchema: z.object({ token: z.string() }),
+      getOutput: async ctx => ({ output: ctx.input })
+    });
+  let spec = SlateSpecification.create({
+    key: 'lifecycle',
+    name: 'Lifecycle',
+    description: 'Trigger lifecycle contract',
+    auth,
+    config: SlateConfig.create(z.object({ tenant: z.string() }))
+  });
+  let selectionSchema =
+    options.selection === 'required'
+      ? z.object({ resource: z.string() })
+      : options.selection === 'default'
+        ? z.object({ resource: z.string().default('default-resource') })
+        : undefined;
+  let record = (operation: string, ctx: { auth: unknown; config: unknown; input: any }) => {
+    contexts.push({ operation, auth: ctx.auth, config: ctx.config, input: ctx.input });
+  };
+  let registration = {
+    webhookRegistrationIdentifier: 'registration',
+    webhookRegistrationPayload: { secret: 'verification' },
+    ...(options.expiresAt !== undefined ? { expiresAt: options.expiresAt } : {}),
+    ...(options.renewAfter !== undefined ? { renewAfter: options.renewAfter } : {})
+  };
+  let group = triggerGroup(spec, { key: 'webhook', name: 'Webhook', selectionSchema })
+    .webhook({
+      reconcileIntervalSeconds: options.reconcileIntervalSeconds,
+      deliveryConfig: options.deliveryConfig
+        ? {
+            userConfigSchema: z.object({ topicName: z.string() }),
+            fullConfigSchema: z.object({ topicName: z.string(), audience: z.string() }),
+            setup: async ctx => {
+              record('setup', ctx);
+              return {
+                webhookSetupDocument: `Deliver to ${ctx.input.webhookUrl}`,
+                partialWebhookRegistrationPayload: {}
+              };
+            },
+            finish: async ctx => {
+              record('finish', ctx);
+              return {
+                webhookRegistrationPayload: {
+                  ...ctx.input.userWebhookRegistrationPayload,
+                  audience: ctx.input.webhookUrl
+                }
+              };
+            },
+            authenticate: async ctx => {
+              record('authenticate', ctx);
+              let status = Number(ctx.input.request.headers.get('x-reject'));
+              if (status) return { rejected: { status } };
+              let body = JSON.parse(await ctx.input.request.text()) as { keys: string[] };
+              return { routingKeys: body.keys };
+            }
+          }
+        : undefined,
+      autoRegistration: {
+        webhookTargetList: async ctx => {
+          record('targets', ctx);
+          return { targets: [], nextPageToken: null };
+        },
+        webhookRegister: async ctx => {
+          record('register', ctx);
+          return registration;
+        },
+        webhookRenew: options.legacy
+          ? undefined
+          : async ctx => {
+              record('renew', ctx);
+              return {
+                ...registration,
+                webhookRegistrationIdentifier: 'renewed-registration'
+              };
+            },
+        webhookUnregister: async () => {}
+      },
+      process: async ctx => {
+        record('process', ctx);
+        return {
+          events: [
+            {
+              payload: { raw: true },
+              matchers: [{ tenant: 'tenant' }],
+              idempotencyKey: 'raw-key'
+            }
+          ]
+        };
+      },
+      expandWebhook: options.legacy
+        ? undefined
+        : async ctx => {
+            record('expand', ctx);
+            // Malformed output deliberately exercises the runtime contract boundary.
+            if (options.invalidExpansion) return { events: [{ payload: [] }] };
+            let payload = z
+              .object({ empty: z.boolean().optional(), preserve: z.boolean().optional() })
+              .nullable()
+              .parse(ctx.input.payload);
+            if (payload?.empty) return { events: [], updatedState: null };
+            if (payload?.preserve) return { events: [] };
+            return {
+              events: [
+                { payload: { kind: 'selected', id: 'one' }, idempotencyKey: 'one' },
+                { payload: { kind: 'other', id: 'two' }, idempotencyKey: 'two' },
+                { payload: { kind: 'selected', id: 'three' }, idempotencyKey: 'three' }
+              ],
+              updatedState: { cursor: 'next' }
+            };
+          }
+    })
+    .routingMatchers(async () => [{ tenant: 'tenant' }])
+    .build();
+  let poll = triggerGroup(spec, { key: 'poll', name: 'Poll', selectionSchema })
+    .polling({
+      pollEvents: async ctx => {
+        record('poll', ctx);
+        return { events: [], updatedState: ctx.input.state };
+      }
+    })
+    .routingMatchers(async () => [])
+    .build();
+  let matches = 0;
+  let selectedInput = z.object({
+    kind: z.string().optional(),
+    id: z.string().optional(),
+    raw: z.boolean().optional()
+  });
+  let selected = SlateTrigger.create(spec, { key: 'selected', name: 'Selected' })
+    .triggerGroup(group)
+    .input(selectedInput)
+    .output(z.object({ id: z.string() }))
+    .matches(payload => {
+      matches++;
+      let event = selectedInput.safeParse(payload);
+      return event.success && (event.data.kind === 'selected' || event.data.raw === true);
+    })
+    .map(async ctx => {
+      let id = ctx.input.id ?? 'raw';
+      return { type: 'selected', id, output: { id } };
+    })
+    .build();
+  let slate = Slate.create({
+    spec,
+    tools: [],
+    triggers: [selected],
+    triggerGroups: [group, poll]
+  });
+  let client = createLocalSlateTestClient({
+    slate,
+    state: {
+      config: { tenant: 'tenant' },
+      auth: { authenticationMethodId: 'token', output: { token: 'credential' } }
+    }
+  });
+  return { client, contexts, matches: () => matches };
+};
+
+let registrationInput = {
+  triggerGroupId: 'webhook',
+  webhookTargetIdentifier: 'target',
+  webhookTargetPayload: { resource: 'target' },
+  webhookUrl: 'https://example.com/webhook'
+};
+let renewalInput = {
+  ...registrationInput,
+  webhookRegistrationIdentifier: 'registration',
+  webhookRegistrationPayload: { secret: 'verification' },
+  operationId: 'stable-operation'
+};
+let expansionInput = {
+  triggerGroupId: 'webhook',
+  payload: { raw: true },
+  state: { cursor: 'before' },
+  deliveryId: 'delivery',
+  webhookRegistrationPayload: { secret: 'verification' }
+};
+
+describe('trigger lifecycle protocol helpers', () => {
+  it('passes the saved delivery config unchanged and independently from user selection', async () => {
+    let { client, contexts } = fixture({ deliveryConfig: true });
+    let deliveryConfig = {
+      topicName: 'projects/p/topics/t',
+      audience: 'https://example.com/delivery',
+      nested: { kept: ['as', 'saved'] }
+    };
+    await registerSlateTriggerGroupWebhook({
+      client,
+      ...registrationInput,
+      operationId: 'initial-registration-operation',
+      deliveryConfig
+    });
+    await renewSlateTriggerGroupWebhook({ client, ...renewalInput, deliveryConfig });
+    expect(contexts.map(ctx => [ctx.operation, ctx.input.deliveryConfig])).toEqual([
+      ['register', deliveryConfig],
+      ['renew', deliveryConfig]
+    ]);
+    expect(contexts[0]?.input.operationId).toBe('initial-registration-operation');
+    await registerSlateTriggerGroupWebhook({
+      client,
+      ...registrationInput,
+      selection: { deliveryConfig }
+    });
+    expect(contexts.at(-1)?.input.deliveryConfig).toBeUndefined();
+    expect(contexts.at(-1)?.input.operationId).toBeUndefined();
+  });
+
+  it('exposes the delivery config of an automatic group and completes it without credentials', async () => {
+    let { client, contexts } = fixture({ deliveryConfig: true });
+    expect((await client.getTriggerGroup('webhook')).triggerGroup.invocation).toMatchObject({
+      registration: {
+        mode: 'auto',
+        deliveryConfig: {
+          userConfigSchema: { type: 'object', required: ['topicName'] },
+          fullConfigSchema: { type: 'object', required: ['topicName', 'audience'] }
+        }
+      }
+    });
+    client.clearAuth();
+    let webhookUrl = 'https://example.com/delivery';
+    let setup = await client.setupTriggerGroupWebhookManually({
+      triggerGroupId: 'webhook',
+      webhookUrl
+    });
+    expect(setup).toEqual({
+      webhookSetupDocument: `Deliver to ${webhookUrl}`,
+      partialWebhookRegistrationPayload: {}
+    });
+    let finished = await client.finishTriggerGroupWebhookManualSetup({
+      triggerGroupId: 'webhook',
+      webhookUrl,
+      partialWebhookRegistrationPayload: setup.partialWebhookRegistrationPayload,
+      userWebhookRegistrationPayload: { topicName: 'projects/p/topics/t' }
+    });
+    expect(finished.webhookRegistrationPayload).toEqual({
+      topicName: 'projects/p/topics/t',
+      audience: webhookUrl
+    });
+    expect(contexts.map(ctx => [ctx.operation, ctx.auth, ctx.config])).toEqual([
+      ['setup', {}, {}],
+      ['finish', {}, {}]
+    ]);
+    await expect(
+      fixture().client.setupTriggerGroupWebhookManually({
+        triggerGroupId: 'webhook',
+        webhookUrl
+      })
+    ).rejects.toThrow('does not support manual webhook registration');
+  });
+
+  it('authenticates a delivery through the delivery config without credentials', async () => {
+    let { client, contexts } = fixture({ deliveryConfig: true });
+    client.clearAuth();
+    let deliveryConfig = {
+      topicName: 'projects/p/topics/t',
+      audience: 'https://example.com/d'
+    };
+    let delivery = {
+      client,
+      triggerGroupId: 'webhook',
+      url: 'https://example.com/d',
+      deliveryConfig
+    };
+    expect(
+      await authenticateSlateTriggerGroupWebhookDelivery({
+        ...delivery,
+        body: JSON.stringify({ keys: ['resource:one', 'resource:two'] })
+      })
+    ).toEqual({ routingKeys: ['resource:one', 'resource:two'], rejected: null });
+    expect(
+      await authenticateSlateTriggerGroupWebhookDelivery({
+        ...delivery,
+        body: JSON.stringify({ keys: [] })
+      })
+    ).toEqual({ routingKeys: [], rejected: null });
+    expect(
+      await authenticateSlateTriggerGroupWebhookDelivery({
+        ...delivery,
+        headers: { 'x-reject': '503' }
+      })
+    ).toEqual({ routingKeys: [], rejected: { status: 503 } });
+    expect(contexts.map(ctx => [ctx.operation, ctx.auth, ctx.config])).toEqual(
+      Array(3).fill(['authenticate', {}, {}])
+    );
+    expect(contexts.map(ctx => ctx.input.deliveryConfig)).toEqual(
+      Array(3).fill(deliveryConfig)
+    );
+    await expect(
+      authenticateSlateTriggerGroupWebhookDelivery({
+        ...delivery,
+        client: fixture().client,
+        body: JSON.stringify({ keys: [] })
+      })
+    ).rejects.toThrow('does not support webhook delivery authentication');
+  });
+
+  it('advertises schemas and capabilities while preserving old group specifications', async () => {
+    let { client } = fixture({ selection: 'default' });
+    expect((await client.getTriggerGroup('webhook')).triggerGroup).toMatchObject({
+      selectionSchema: {
+        type: 'object',
+        properties: { resource: { type: 'string', default: 'default-resource' } }
+      },
+      invocation: { type: 'webhook', supportsExpansion: true, supportsRenewal: true }
+    });
+    let legacy = fixture({ legacy: true });
+    let oldGroup = (await legacy.client.getTriggerGroup('webhook')).triggerGroup;
+    expect(oldGroup).not.toHaveProperty('selectionSchema');
+    expect(oldGroup.invocation).toEqual({ type: 'webhook', registration: { mode: 'auto' } });
+    expect(
+      (await client.getTriggerGroup('webhook')).triggerGroup.selectionSchema
+    ).not.toHaveProperty('required');
+  });
+
+  it('declares bounded reconciliation and passes scheduled null payloads unchanged', async () => {
+    for (let reconcileIntervalSeconds of [
+      0,
+      899,
+      900.5,
+      Number.NaN,
+      Number.POSITIVE_INFINITY
+    ]) {
+      expect(() => fixture({ reconcileIntervalSeconds })).toThrow(
+        'integer of at least 900 seconds'
+      );
+    }
+    expect(() => fixture({ legacy: true, reconcileIntervalSeconds: 900 })).toThrow(
+      'requires an expandWebhook handler'
+    );
+    let { client, contexts } = fixture({ reconcileIntervalSeconds: 900 });
+    expect((await client.getTriggerGroup('webhook')).triggerGroup.invocation).toMatchObject({
+      reconcileIntervalSeconds: 900,
+      supportsExpansion: true
+    });
+    let result = await expandSlateTriggerGroupWebhook({
+      client,
+      ...expansionInput,
+      payload: null,
+      deliveryId: 'scheduled-run'
+    });
+    expect(result.events).toHaveLength(3);
+    expect(contexts[0]?.input).toMatchObject({
+      payload: null,
+      deliveryId: 'scheduled-run',
+      state: expansionInput.state,
+      webhookRegistrationPayload: expansionInput.webhookRegistrationPayload
+    });
+  });
+
+  it('verifies without credentials and expands zero or many events with connection context', async () => {
+    let { client, contexts, matches } = fixture({ selection: 'required' });
+    let processed = await processSlateTriggerGroupWebhook({
+      client,
+      triggerGroupId: 'webhook',
+      url: registrationInput.webhookUrl,
+      webhookRegistrationPayload: expansionInput.webhookRegistrationPayload
+    });
+    expect(processed).toMatchObject({
+      requiresExpansion: true,
+      events: [{ triggerIds: [], idempotencyKey: 'raw-key' }]
+    });
+    expect(matches()).toBe(0);
+    expect(contexts[0]).toMatchObject({ operation: 'process', auth: {}, config: {} });
+    let expanded = await expandSlateTriggerGroupWebhook({
+      client,
+      ...expansionInput,
+      selection: { resource: 'chosen' }
+    });
+    expect(expanded).toMatchObject({
+      updatedState: { cursor: 'next' },
+      events: [
+        { idempotencyKey: 'one', triggerIds: ['selected'] },
+        { idempotencyKey: 'two', triggerIds: [] },
+        { idempotencyKey: 'three', triggerIds: ['selected'] }
+      ]
+    });
+    expect(contexts[1]).toMatchObject({
+      operation: 'expand',
+      auth: { token: 'credential' },
+      config: { tenant: 'tenant' },
+      input: {
+        payload: expansionInput.payload,
+        state: expansionInput.state,
+        deliveryId: expansionInput.deliveryId,
+        webhookRegistrationPayload: expansionInput.webhookRegistrationPayload,
+        selection: { resource: 'chosen' }
+      }
+    });
+    expect(matches()).toBe(3);
+    expect(
+      await client.mapTriggerEvent('selected', expanded.events[0]!.payload)
+    ).toMatchObject({ output: { id: 'one' } });
+    let cleared = await expandSlateTriggerGroupWebhook({
+      client,
+      ...expansionInput,
+      payload: { empty: true },
+      selection: { resource: 'chosen' }
+    });
+    expect(cleared).toMatchObject({ events: [], updatedState: null });
+    let preserved = await expandSlateTriggerGroupWebhook({
+      client,
+      ...expansionInput,
+      payload: { preserve: true },
+      selection: { resource: 'chosen' }
+    });
+    expect(preserved.events).toEqual([]);
+    expect(preserved).not.toHaveProperty('updatedState');
+  });
+
+  it('validates selection before every affected handler and applies accepted defaults', async () => {
+    let { client, contexts } = fixture({ selection: 'required' });
+    let calls = [
+      () => client.listTriggerGroupWebhookTargets({ triggerGroupId: 'webhook' }),
+      () => registerSlateTriggerGroupWebhook({ client, ...registrationInput }),
+      () => renewSlateTriggerGroupWebhook({ client, ...renewalInput }),
+      () => expandSlateTriggerGroupWebhook({ client, ...expansionInput }),
+      () => pollSlateTriggerGroupEvents({ client, triggerGroupId: 'poll' })
+    ];
+    for (let call of calls) await expect(call()).rejects.toThrow('Invalid selection');
+    expect(contexts).toEqual([]);
+    let defaults = fixture({ selection: 'default' });
+    await defaults.client.listTriggerGroupWebhookTargets({ triggerGroupId: 'webhook' });
+    await registerSlateTriggerGroupWebhook({ client: defaults.client, ...registrationInput });
+    await renewSlateTriggerGroupWebhook({ client: defaults.client, ...renewalInput });
+    await expandSlateTriggerGroupWebhook({ client: defaults.client, ...expansionInput });
+    await pollSlateTriggerGroupEvents({ client: defaults.client, triggerGroupId: 'poll' });
+    expect(defaults.contexts.map(ctx => ctx.input.selection)).toEqual(
+      Array(5).fill({ resource: 'default-resource' })
+    );
+    await pollSlateTriggerGroupEvents({
+      client: defaults.client,
+      triggerGroupId: 'poll',
+      selection: { resource: 'explicit' }
+    });
+    expect(defaults.contexts.at(-1)?.input.selection).toEqual({ resource: 'explicit' });
+  });
+
+  it('keeps groups without selection, expansion, or renewal backward compatible', async () => {
+    let { client, contexts } = fixture({ legacy: true });
+    await registerSlateTriggerGroupWebhook({ client, ...registrationInput });
+    await pollSlateTriggerGroupEvents({ client, triggerGroupId: 'poll' });
+    expect(contexts.map(ctx => ctx.input.selection)).toEqual([{}, {}]);
+    let processed = await processSlateTriggerGroupWebhook({
+      client,
+      triggerGroupId: 'webhook',
+      url: registrationInput.webhookUrl
+    });
+    expect(processed.events[0]?.triggerIds).toEqual(['selected']);
+    expect(processed).not.toHaveProperty('requiresExpansion');
+    await expect(renewSlateTriggerGroupWebhook({ client, ...renewalInput })).rejects.toThrow(
+      'does not support webhook renewal'
+    );
+    await expect(
+      expandSlateTriggerGroupWebhook({ client, ...expansionInput })
+    ).rejects.toThrow('does not support webhook expansion');
+  });
+
+  it('requires authenticated context for expansion and renewal', async () => {
+    let { client, contexts } = fixture();
+    client.clearAuth();
+    await expect(
+      expandSlateTriggerGroupWebhook({ client, ...expansionInput })
+    ).rejects.toMatchObject({
+      data: { code: 'request.precondition_failed' }
+    });
+    await expect(
+      renewSlateTriggerGroupWebhook({ client, ...renewalInput })
+    ).rejects.toMatchObject({
+      data: { code: 'request.precondition_failed' }
+    });
+    expect(contexts).toEqual([]);
+    await processSlateTriggerGroupWebhook({
+      client,
+      triggerGroupId: 'webhook',
+      url: registrationInput.webhookUrl
+    });
+    expect(contexts[0]).toMatchObject({ operation: 'process', auth: {}, config: {} });
+  });
+
+  it('passes stable renewal identity and validates nullable ISO scheduling metadata', async () => {
+    let { client, contexts } = fixture({
+      expiresAt: '2026-12-01T12:00:00+01:00',
+      renewAfter: null
+    });
+    let registered = await registerSlateTriggerGroupWebhook({ client, ...registrationInput });
+    expect(registered).toMatchObject({
+      expiresAt: '2026-12-01T12:00:00+01:00',
+      renewAfter: null
+    });
+    let renewed = await renewSlateTriggerGroupWebhook({
+      client,
+      ...renewalInput,
+      selection: { resource: 'chosen' }
+    });
+    expect(renewed).toMatchObject({
+      webhookRegistrationIdentifier: 'renewed-registration',
+      expiresAt: registered.expiresAt,
+      renewAfter: null
+    });
+    expect(contexts.at(-1)).toMatchObject({
+      operation: 'renew',
+      auth: { token: 'credential' },
+      config: { tenant: 'tenant' },
+      input: {
+        operationId: 'stable-operation',
+        webhookRegistrationIdentifier: 'registration',
+        webhookTargetIdentifier: 'target',
+        selection: { resource: 'chosen' }
+      }
+    });
+    let invalid = fixture({ expiresAt: 'tomorrow' });
+    await expect(
+      registerSlateTriggerGroupWebhook({ client: invalid.client, ...registrationInput })
+    ).rejects.toThrow('invalid result');
+    await expect(
+      renewSlateTriggerGroupWebhook({ client: invalid.client, ...renewalInput })
+    ).rejects.toThrow('invalid result');
+    let invalidExpansion = fixture({ invalidExpansion: true });
+    await expect(
+      expandSlateTriggerGroupWebhook({ client: invalidExpansion.client, ...expansionInput })
+    ).rejects.toThrow('invalid result');
+  });
+});