@slates/provider 1.0.0-rc.22 → 1.0.0-rc.23

package/src/action/trigger.ts

@@ -3,17 +3,11 @@ import type { SlateSpecification } from '../specification/specification';
 import {
   SlateAction,
   type SlateActionParameters,
-  type SlatePollingOptions,
   type SlateTriggerMappingHandler,
-  type SlateTriggerPollingHandler,
-  type SlateTriggerWebhookAutoRegistrationHandler,
-  type SlateTriggerWebhookAutoUnregistrationHandler,
-  type SlateTriggerWebhookRequestHandler,
-  type SlateWebhookHttpOptions
+  type SlateTriggerMatchesHandler
 } from './action';
 import { SlateActionBuilder } from './builder';
-
-export let SlateDefaultPollingIntervalSeconds = 60 * 10;
+import type { SlateTriggerGroup } from './triggerGroup';
 
 export interface SlateTriggerParameters<
   ConfigType extends {},
@@ -24,14 +18,9 @@ export interface SlateTriggerParameters<
   }
 > extends SlateActionParameters {
   type: 'trigger';
-  source: 'polling' | 'webhook';
-  polling?: SlatePollingOptions;
-  handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-  handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
-  http?: SlateWebhookHttpOptions;
-  pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
-  autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
-  autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+  triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
+  matches: SlateTriggerMatchesHandler;
+  map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
 }
 
 export class SlateTrigger<
@@ -42,14 +31,9 @@ export class SlateTrigger<
     type: string;
   }
 > extends SlateAction<'trigger', ConfigType, AuthType, InputType, OutputType> {
-  #source: 'polling' | 'webhook';
-  #polling: SlatePollingOptions;
-  #handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-  #handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
-  #http?: SlateWebhookHttpOptions;
-  #pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
-  #autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
-  #autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+  #triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
+  #matches: SlateTriggerMatchesHandler;
+  #map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
 
   private constructor(
     spec: SlateSpecification<ConfigType, AuthType>,
@@ -59,16 +43,9 @@ export class SlateTrigger<
   ) {
     super('trigger', spec, inputSchema, outputSchema, params);
 
-    this.#source = params.source;
-    this.#polling = params.polling || {
-      intervalInSeconds: SlateDefaultPollingIntervalSeconds
-    };
-    this.#handleEvent = params.handleEvent;
-    this.#handleRequest = params.handleRequest;
-    this.#http = params.http;
-    this.#pollEvents = params.pollEvents;
-    this.#autoRegisterWebhook = params.autoRegisterWebhook;
-    this.#autoUnregisterWebhook = params.autoUnregisterWebhook;
+    this.#triggerGroup = params.triggerGroup;
+    this.#matches = params.matches;
+    this.#map = params.map;
   }
 
   static create<ConfigType extends {}, AuthType extends {}>(
@@ -81,36 +58,16 @@ export class SlateTrigger<
     });
   }
 
-  get polling() {
-    return this.#polling;
-  }
-
-  get source() {
-    return this.#source;
-  }
-
-  get handleEvent() {
-    return this.#handleEvent;
-  }
-
-  get handleRequest() {
-    return this.#handleRequest;
-  }
-
-  get http() {
-    return this.#http;
-  }
-
-  get pollEvents() {
-    return this.#pollEvents;
+  get triggerGroup() {
+    return this.#triggerGroup;
   }
 
-  get autoRegisterWebhook() {
-    return this.#autoRegisterWebhook;
+  get matches() {
+    return this.#matches;
   }
 
-  get autoUnregisterWebhook() {
-    return this.#autoUnregisterWebhook;
+  get map() {
+    return this.#map;
   }
 }
 

package/src/action/triggerGroup.ts

@@ -0,0 +1,296 @@
+import type z from 'zod';
+import { SlateDeclarationError } from '../error';
+import type { SlateSpecification } from '../specification/specification';
+import type { SlateContext } from '../context';
+import type { SlateWebhookHttpResponseInit } from './action';
+
+export let SlateDefaultPollingIntervalSeconds = 60 * 10;
+
+export type SlateTriggerRoutingMatcher = Record<string, any>;
+
+export type SlateWebhookTargetOwnership = 'single_user' | 'multi_user';
+
+export interface SlateWebhookTarget {
+  webhookTargetIdentifier: string;
+  name: string;
+  description?: string;
+  metadata: Record<string, any>;
+  webhookTargetPayload: any;
+  targetOwnership: SlateWebhookTargetOwnership;
+}
+
+export type SlateTriggerGroupRoutingMatchersHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<ConfigType, AuthType, {}>
+) => Promise<SlateTriggerRoutingMatcher[]>;
+
+export type SlateTriggerGroupPollHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<ConfigType, AuthType, { state: any | null }>
+) => Promise<{
+  events: { payload: any; idempotencyKey?: string }[];
+  updatedState?: any;
+}>;
+
+export type SlateWebhookTargetListHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<ConfigType, AuthType, { pageToken: any | null }>
+) => Promise<{
+  targets: SlateWebhookTarget[];
+  nextPageToken: any | null;
+}>;
+
+export type SlateWebhookRegisterHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<
+    ConfigType,
+    AuthType,
+    {
+      webhookTargetIdentifier: string;
+      webhookTargetPayload: any;
+      webhookUrl: string;
+    }
+  >
+) => Promise<{
+  webhookRegistrationIdentifier: string;
+  webhookRegistrationPayload: any;
+}>;
+
+export type SlateWebhookUnregisterHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<
+    ConfigType,
+    AuthType,
+    {
+      webhookRegistrationIdentifier: string;
+      webhookRegistrationPayload: any;
+    }
+  >
+) => Promise<unknown>;
+
+export type SlateWebhookManualSetupHandler<FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> =
+  (
+    context: SlateContext<{}, {}, { webhookUrl: string }>
+  ) => Promise<{
+    webhookSetupDocument: string;
+    partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
+  }>;
+
+export type SlateWebhookManualFinishHandler<
+  UserConfigSchema extends z.ZodType<any> = z.ZodType<any>,
+  FullConfigSchema extends z.ZodType<any> = z.ZodType<any>
+> = (
+  context: SlateContext<
+    {},
+    {},
+    {
+      webhookUrl: string;
+      partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
+      userWebhookRegistrationPayload: z.infer<UserConfigSchema>;
+    }
+  >
+) => Promise<{
+  webhookRegistrationPayload: z.infer<FullConfigSchema>;
+}>;
+
+export type SlateWebhookProcessHandler = (
+  context: SlateContext<
+    {},
+    {},
+    {
+      request: Request;
+      webhookRegistrationPayload: any;
+    }
+  >
+) => Promise<{
+  events: {
+    matchers: SlateTriggerRoutingMatcher[];
+    payload: any;
+    idempotencyKey?: string;
+  }[];
+  response?: Response | SlateWebhookHttpResponseInit;
+}>;
+
+export interface SlateTriggerGroupPollingParameters<ConfigType extends {}, AuthType extends {}> {
+  intervalSeconds: number;
+  pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
+}
+
+export interface SlateTriggerGroupWebhookAutoRegistrationParameters<
+  ConfigType extends {},
+  AuthType extends {}
+> {
+  webhookTargetList: SlateWebhookTargetListHandler<ConfigType, AuthType>;
+  webhookRegister: SlateWebhookRegisterHandler<ConfigType, AuthType>;
+  webhookUnregister: SlateWebhookUnregisterHandler<ConfigType, AuthType>;
+}
+
+export interface SlateTriggerGroupWebhookManualRegistrationParameters<
+  UserConfigSchema extends z.ZodType<any> = z.ZodType<any>,
+  FullConfigSchema extends z.ZodType<any> = z.ZodType<any>
+> {
+  userConfigSchema: UserConfigSchema;
+  fullConfigSchema: FullConfigSchema;
+  setup: SlateWebhookManualSetupHandler<FullConfigSchema>;
+  finish?: SlateWebhookManualFinishHandler<UserConfigSchema, FullConfigSchema>;
+}
+
+export interface SlateTriggerGroupWebhookParameters<ConfigType extends {}, AuthType extends {}> {
+  autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
+  manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<any, any>;
+  process: SlateWebhookProcessHandler;
+}
+
+export interface SlateTriggerGroupCreateParameters {
+  key: string;
+  name: string;
+  description?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}>
+  extends SlateTriggerGroupCreateParameters {
+  source: 'polling' | 'webhook';
+  polling?: SlateTriggerGroupPollingParameters<ConfigType, AuthType>;
+  webhook?: SlateTriggerGroupWebhookParameters<ConfigType, AuthType>;
+  routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
+}
+
+export class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}> {
+  private constructor(
+    private readonly _spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly _params: SlateTriggerGroupParameters<ConfigType, AuthType>
+  ) {}
+
+  static create<ConfigType extends {}, AuthType extends {}>(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateTriggerGroupCreateParameters
+  ) {
+    return new SlateTriggerGroupBuilder(spec, params, p => new SlateTriggerGroup(spec, p));
+  }
+
+  get spec() {
+    return this._spec;
+  }
+
+  get key() {
+    return this._params.key;
+  }
+
+  get name() {
+    return this._params.name;
+  }
+
+  get description() {
+    return this._params.description;
+  }
+
+  get metadata() {
+    return this._params.metadata;
+  }
+
+  get source() {
+    return this._params.source;
+  }
+
+  get polling() {
+    return this._params.polling;
+  }
+
+  get webhook() {
+    return this._params.webhook;
+  }
+
+  get routingMatchers() {
+    return this._params.routingMatchers;
+  }
+}
+
+export class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}> {
+  #source: 'polling' | 'webhook' | null = null;
+  #polling: SlateTriggerGroupPollingParameters<ConfigType, AuthType> | null = null;
+  #webhook: SlateTriggerGroupWebhookParameters<ConfigType, AuthType> | null = null;
+  #routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType> | null = null;
+
+  constructor(
+    private readonly spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly params: SlateTriggerGroupCreateParameters,
+    private readonly factory: (
+      params: SlateTriggerGroupParameters<ConfigType, AuthType>
+    ) => SlateTriggerGroup<ConfigType, AuthType>
+  ) {}
+
+  polling(props: {
+    intervalSeconds?: number;
+    pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
+  }): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+    if (this.#source) {
+      throw new SlateDeclarationError('Trigger group invocation is already defined');
+    }
+
+    this.#source = 'polling';
+    this.#polling = {
+      intervalSeconds: props.intervalSeconds ?? SlateDefaultPollingIntervalSeconds,
+      pollEvents: props.pollEvents
+    };
+
+    return this;
+  }
+
+  webhook<
+    UserConfigSchema extends z.ZodType<any> = z.ZodType<any>,
+    FullConfigSchema extends z.ZodType<any> = z.ZodType<any>
+  >(props: {
+    autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
+    manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<
+      UserConfigSchema,
+      FullConfigSchema
+    >;
+    process: SlateWebhookProcessHandler;
+  }): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+    if (this.#source) {
+      throw new SlateDeclarationError('Trigger group invocation is already defined');
+    }
+
+    if (!!props.autoRegistration === !!props.manualRegistration) {
+      throw new SlateDeclarationError(
+        'Webhook trigger groups require exactly one of autoRegistration or manualRegistration'
+      );
+    }
+
+    this.#source = 'webhook';
+    this.#webhook = {
+      autoRegistration: props.autoRegistration,
+      manualRegistration: props.manualRegistration,
+      process: props.process
+    };
+
+    return this;
+  }
+
+  routingMatchers(
+    handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>
+  ): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+    this.#routingMatchers = handler;
+    return this;
+  }
+
+  build(): SlateTriggerGroup<ConfigType, AuthType> {
+    if (!this.#source) {
+      throw new SlateDeclarationError(
+        'Trigger group invocation (polling or webhook) is not defined'
+      );
+    }
+    if (!this.#routingMatchers) {
+      throw new SlateDeclarationError('Trigger group routing matchers handler is not defined');
+    }
+
+    return this.factory({
+      ...this.params,
+      source: this.#source,
+      polling: this.#polling ?? undefined,
+      webhook: this.#webhook ?? undefined,
+      routingMatchers: this.#routingMatchers
+    });
+  }
+}
+
+export let triggerGroup = <ConfigType extends {}, AuthType extends {}>(
+  spec: SlateSpecification<ConfigType, AuthType>,
+  params: SlateTriggerGroupCreateParameters
+) => SlateTriggerGroup.create(spec, params);

package/src/adapter/index.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { z } from 'zod';
 import { SlateTool } from '../action/tool';
+import { SlateTriggerGroup } from '../action/triggerGroup';
 import { SlateAuth } from '../auth';
 import { SlateConfig } from '../config';
 import { Slate } from '../specification/slate';
@@ -41,6 +42,16 @@ describe('SlateAdapterSpec', () => {
       }))
       .build();
 
+    let emailTriggerGroup = SlateTriggerGroup.create(spec, {
+      key: 'emails',
+      name: 'Emails'
+    })
+      .polling({
+        pollEvents: async () => ({ events: [] })
+      })
+      .routingMatchers(async () => [])
+      .build();
+
     let emailReceivedTrigger = gmailAdapterSpec
       .trigger(spec, {
         key: 'email_received',
@@ -48,13 +59,13 @@ describe('SlateAdapterSpec', () => {
       })
       .input(z.object({ messageId: z.string() }))
       .output(z.object({ type: z.literal('email.received') }))
-      .polling({
-        handleEvent: async ctx => ({
-          type: 'email.received',
-          id: ctx.input.messageId,
-          output: { type: 'email.received' as const }
-        })
-      })
+      .triggerGroup(emailTriggerGroup)
+      .matches(() => true)
+      .map(async ctx => ({
+        type: 'email.received',
+        id: ctx.input.messageId,
+        output: { type: 'email.received' as const }
+      }))
       .build();
 
     expect(sendEmailTool.adapter).toBe('gmail');
@@ -218,6 +229,16 @@ describe('SlateAdapterSpec', () => {
       }))
       .build();
 
+    let sendEmailTriggerGroup = SlateTriggerGroup.create(spec, {
+      key: 'sent_emails',
+      name: 'Sent Emails'
+    })
+      .polling({
+        pollEvents: async () => ({ events: [] })
+      })
+      .routingMatchers(async () => [])
+      .build();
+
     let sendEmailTrigger = gmailAdapterSpec
       .trigger(spec, {
         key: 'send_email',
@@ -225,13 +246,13 @@ describe('SlateAdapterSpec', () => {
       })
       .input(z.object({}))
       .output(z.object({ type: z.string() }))
-      .polling({
-        handleEvent: async () => ({
-          type: 'email.sent',
-          id: '1',
-          output: { type: 'email.sent' }
-        })
-      })
+      .triggerGroup(sendEmailTriggerGroup)
+      .matches(() => true)
+      .map(async () => ({
+        type: 'email.sent',
+        id: '1',
+        output: { type: 'email.sent' }
+      }))
       .build();
 
     expect(() =>

package/src/module/resolveDefaultExport.test.ts

@@ -19,9 +19,9 @@ describe('resolveDefaultExport', () => {
   });
 
   it('unwraps nested default exports from double-bundling', () => {
-    expect(
-      resolveDefaultExport<typeof Example>({ default: { default: Example } })
-    ).toBe(Example);
+    expect(resolveDefaultExport<typeof Example>({ default: { default: Example } })).toBe(
+      Example
+    );
   });
 
   it('throws when the export is not a constructor', () => {

package/src/specification/slate.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { SlateTrigger, SlateTriggerGroup } from '../action';
+import { SlateAuth } from '../auth';
+import { SlateConfig } from '../config';
+import { Slate } from './slate';
+import { SlateSpecification } from './specification';
+
+let createTestSpec = () => {
+  let config = SlateConfig.create(z.object({}));
+  let auth = SlateAuth.create<{}>().output(z.object({}));
+
+  return SlateSpecification.create({
+    key: 'demo',
+    name: 'Demo',
+    config,
+    auth
+  });
+};
+
+let createManualWebhookTriggerGroup = (spec: ReturnType<typeof createTestSpec>, key: string) =>
+  SlateTriggerGroup.create(spec, {
+    key,
+    name: key
+  })
+    .webhook({
+      manualRegistration: {
+        userConfigSchema: z.object({}),
+        fullConfigSchema: z.object({}),
+        setup: async () => ({
+          webhookSetupDocument: '',
+          partialWebhookRegistrationPayload: {}
+        })
+      },
+      process: async () => ({ events: [] })
+    })
+    .routingMatchers(async () => [])
+    .build();
+
+let createAutoWebhookTriggerGroup = (spec: ReturnType<typeof createTestSpec>, key: string) =>
+  SlateTriggerGroup.create(spec, {
+    key,
+    name: key
+  })
+    .webhook({
+      autoRegistration: {
+        webhookTargetList: async () => ({ targets: [], nextPageToken: null }),
+        webhookRegister: async () => ({
+          webhookRegistrationIdentifier: 'reg',
+          webhookRegistrationPayload: {}
+        }),
+        webhookUnregister: async () => {}
+      },
+      process: async () => ({ events: [] })
+    })
+    .routingMatchers(async () => [])
+    .build();
+
+describe('Slate.create', () => {
+  it('rejects more than one manual webhook trigger group', () => {
+    let spec = createTestSpec();
+    let first = createManualWebhookTriggerGroup(spec, 'manual_one');
+    let second = createManualWebhookTriggerGroup(spec, 'manual_two');
+
+    expect(() =>
+      Slate.create({
+        spec,
+        tools: [],
+        triggers: [],
+        triggerGroups: [first, second]
+      })
+    ).toThrow(
+      'Only one trigger group may use manual webhook registration, but found: manual_one, manual_two'
+    );
+  });
+
+  it('allows a single manual webhook trigger group alongside other trigger groups', () => {
+    let spec = createTestSpec();
+    let manual = createManualWebhookTriggerGroup(spec, 'manual_group');
+    let auto = createAutoWebhookTriggerGroup(spec, 'auto_group');
+
+    let manualTrigger = SlateTrigger.create(spec, {
+      key: 'manual_trigger',
+      name: 'Manual Trigger'
+    })
+      .input(z.object({}))
+      .output(z.object({ type: z.literal('demo') }))
+      .triggerGroup(manual)
+      .matches(() => true)
+      .map(async () => ({ type: 'demo', id: '1', output: { type: 'demo' as const } }))
+      .build();
+
+    let slate = Slate.create({
+      spec,
+      tools: [],
+      triggers: [manualTrigger],
+      triggerGroups: [manual, auto]
+    });
+
+    expect(slate.triggerGroups.map(group => group.key)).toEqual(['manual_group', 'auto_group']);
+  });
+});

package/src/specification/slate.ts

@@ -1,4 +1,4 @@
-import type { SlateTool, SlateTrigger } from '../action';
+import type { SlateTool, SlateTrigger, SlateTriggerGroup } from '../action';
 import type { SlateAdapter } from '../adapter';
 import { SlateDeclarationError } from '../error';
 import type { SlateSpecification } from './specification';
@@ -10,7 +10,8 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
       | SlateTrigger<ConfigType, AuthType, any, any>
       | SlateTool<ConfigType, AuthType, any, any>
     )[],
-    private readonly _adapters: SlateAdapter<ConfigType, AuthType>[]
+    private readonly _adapters: SlateAdapter<ConfigType, AuthType>[],
+    private readonly _triggerGroups: SlateTriggerGroup<ConfigType, AuthType>[]
   ) {}
 
   static create<ConfigType extends {}, AuthType extends {}>(params: {
@@ -18,6 +19,7 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
     triggers: SlateTrigger<ConfigType, AuthType, any, any>[];
     tools: SlateTool<ConfigType, AuthType, any, any>[];
     adapters?: SlateAdapter<ConfigType, AuthType>[];
+    triggerGroups?: SlateTriggerGroup<ConfigType, AuthType>[];
   }) {
     let adapters = params.adapters ?? [];
     let actions = [...params.triggers, ...params.tools];
@@ -47,7 +49,29 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
       }
     }
 
-    return new Slate(params.spec, actions, adapters);
+    let triggerGroups = params.triggerGroups ?? [];
+    let seenTriggerGroupKeys = new Set<string>();
+    for (let group of triggerGroups) {
+      if (seenTriggerGroupKeys.has(group.key)) {
+        throw new SlateDeclarationError(
+          `Trigger group "${group.key}" is registered more than once`
+        );
+      }
+      seenTriggerGroupKeys.add(group.key);
+    }
+
+    let manualWebhookTriggerGroups = triggerGroups.filter(
+      group => group.source === 'webhook' && group.webhook?.manualRegistration
+    );
+    if (manualWebhookTriggerGroups.length > 1) {
+      throw new SlateDeclarationError(
+        `Only one trigger group may use manual webhook registration, but found: ${manualWebhookTriggerGroups
+          .map(group => group.key)
+          .join(', ')}`
+      );
+    }
+
+    return new Slate(params.spec, actions, adapters, triggerGroups);
   }
 
   get spec() {
@@ -61,4 +85,8 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
   get adapters() {
     return this._adapters;
   }
+
+  get triggerGroups() {
+    return this._triggerGroups;
+  }
 }

package/src/webhook/graph.ts

@@ -1,4 +1,4 @@
-import type { SlateWebhookHttpOptions, SlateWebhookHttpResponseInit } from '../action';
+import type { SlateWebhookHttpResponseInit } from '../action';
 
 export const graphWebhookHttp = {
   methods: ['POST'],
@@ -6,7 +6,7 @@ export const graphWebhookHttp = {
     mode: 'match',
     match: [{ hasQueryParam: 'validationToken' }]
   }
-} satisfies SlateWebhookHttpOptions;
+};
 
 export let getGraphWebhookValidationResponse = (
   request: Request