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

package/dist/index.cjs

@@ -1248,6 +1248,7 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
 var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
 
 // src/action/triggerGroup.ts
+var import_zod2 = require("zod");
 var SlateDefaultPollingIntervalSeconds = 60 * 10;
 var SlateTriggerGroup = class _SlateTriggerGroup {
   constructor(_spec, _params) {
@@ -1274,6 +1275,9 @@ var SlateTriggerGroup = class _SlateTriggerGroup {
   get metadata() {
     return this._params.metadata;
   }
+  get eventSchema() {
+    return this._params.eventSchema ?? import_zod2.z.object({}).passthrough();
+  }
   get source() {
     return this._params.source;
   }
@@ -2847,7 +2851,7 @@ var Slate = class _Slate {
 };
 
 // src/specification/specification.ts
-var import_zod2 = __toESM(require("zod"), 1);
+var import_zod3 = __toESM(require("zod"), 1);
 var SlateSpecification = class _SlateSpecification {
   constructor(_config, _auth, _params) {
     this._config = _config;
@@ -2864,7 +2868,7 @@ var SlateSpecification = class _SlateSpecification {
     return this._config.configSchema;
   }
   get authSchema() {
-    return "outputSchema" in this._auth ? this._auth.outputSchema : import_zod2.default.object({});
+    return "outputSchema" in this._auth ? this._auth.outputSchema : import_zod3.default.object({});
   }
   get config() {
     return this._config;

package/dist/index.d.cts

@@ -149,6 +149,7 @@ type SlateAuthWithOauth<InputType extends {}, OutputType extends {
         description?: string;
         scope: string;
     }[];
+    adapters?: string[];
     docs?: SlateAuthDocsReference[];
     inputSchema?: z.ZodType<InputType>;
     onInputChanged?: (params: {
@@ -213,6 +214,7 @@ type SlateAuthWithToken<InputType extends {}, OutputType extends {
     type: 'auth.token';
     name: string;
     key: string;
+    adapters?: string[];
     inputSchema?: z.ZodType<InputType>;
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
@@ -242,6 +244,7 @@ type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> =
     type: 'auth.service_account';
     name: string;
     key: string;
+    adapters?: string[];
     inputSchema?: z.ZodType<InputType>;
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
@@ -271,6 +274,7 @@ type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
     type: 'auth.custom';
     name: string;
     key: string;
+    adapters?: string[];
     inputSchema?: z.ZodType<InputType>;
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
@@ -523,6 +527,7 @@ type SlateWebhookTargetListHandler<ConfigType extends {}, AuthType extends {}> =
 }>) => Promise<{
     targets: SlateWebhookTarget[];
     nextPageToken: any | null;
+    isPartial?: boolean;
 }>;
 type SlateWebhookRegisterHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     webhookTargetIdentifier: string;
@@ -536,18 +541,18 @@ type SlateWebhookUnregisterHandler<ConfigType extends {}, AuthType extends {}> =
     webhookRegistrationIdentifier: string;
     webhookRegistrationPayload: any;
 }>) => Promise<unknown>;
-type SlateWebhookManualSetupHandler<FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> = (context: SlateContext<{}, {}, {
+type SlateWebhookManualSetupHandler<FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> = (context: SlateContext<{}, {}, {
     webhookUrl: string;
 }>) => Promise<{
     webhookSetupDocument: string;
-    partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
+    partialWebhookRegistrationPayload: Partial<z$1.infer<FullConfigSchema>>;
 }>;
-type SlateWebhookManualFinishHandler<UserConfigSchema extends z.ZodType<any> = z.ZodType<any>, FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> = (context: SlateContext<{}, {}, {
+type SlateWebhookManualFinishHandler<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> = (context: SlateContext<{}, {}, {
     webhookUrl: string;
-    partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
-    userWebhookRegistrationPayload: z.infer<UserConfigSchema>;
+    partialWebhookRegistrationPayload: Partial<z$1.infer<FullConfigSchema>>;
+    userWebhookRegistrationPayload: z$1.infer<UserConfigSchema>;
 }>) => Promise<{
-    webhookRegistrationPayload: z.infer<FullConfigSchema>;
+    webhookRegistrationPayload: z$1.infer<FullConfigSchema>;
 }>;
 type SlateWebhookProcessHandler = (context: SlateContext<{}, {}, {
     request: Request;
@@ -569,7 +574,7 @@ interface SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType extends
     webhookRegister: SlateWebhookRegisterHandler<ConfigType, AuthType>;
     webhookUnregister: SlateWebhookUnregisterHandler<ConfigType, AuthType>;
 }
-interface SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema extends z.ZodType<any> = z.ZodType<any>, FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> {
+interface SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> {
     userConfigSchema: UserConfigSchema;
     fullConfigSchema: FullConfigSchema;
     setup: SlateWebhookManualSetupHandler<FullConfigSchema>;
@@ -580,52 +585,54 @@ interface SlateTriggerGroupWebhookParameters<ConfigType extends {}, AuthType ext
     manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<any, any>;
     process: SlateWebhookProcessHandler;
 }
-interface SlateTriggerGroupCreateParameters {
+interface SlateTriggerGroupCreateParameters<InputType extends {} = Record<string, unknown>> {
     key: string;
     name: string;
     description?: string;
     metadata?: Record<string, any>;
+    eventSchema?: z$1.ZodType<InputType>;
 }
-interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}> extends SlateTriggerGroupCreateParameters {
+interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> extends SlateTriggerGroupCreateParameters<InputType> {
     source: 'polling' | 'webhook';
     polling?: SlateTriggerGroupPollingParameters<ConfigType, AuthType>;
     webhook?: SlateTriggerGroupWebhookParameters<ConfigType, AuthType>;
     routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
 }
-declare class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}> {
+declare class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> {
     private readonly _spec;
     private readonly _params;
     private constructor();
-    static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters): SlateTriggerGroupBuilder<ConfigType, AuthType>;
+    static create<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters<InputType>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
     get spec(): SlateSpecification<ConfigType, AuthType>;
     get key(): string;
     get name(): string;
     get description(): string | undefined;
     get metadata(): Record<string, any> | undefined;
+    get eventSchema(): z$1.ZodType<InputType, unknown, z$1.core.$ZodTypeInternals<InputType, unknown>>;
     get source(): "polling" | "webhook";
     get polling(): SlateTriggerGroupPollingParameters<ConfigType, AuthType> | undefined;
     get webhook(): SlateTriggerGroupWebhookParameters<ConfigType, AuthType> | undefined;
     get routingMatchers(): SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
 }
-declare class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}> {
+declare class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> {
     #private;
     private readonly spec;
     private readonly params;
     private readonly factory;
-    constructor(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters, factory: (params: SlateTriggerGroupParameters<ConfigType, AuthType>) => SlateTriggerGroup<ConfigType, AuthType>);
+    constructor(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters<InputType>, factory: (params: SlateTriggerGroupParameters<ConfigType, AuthType, InputType>) => SlateTriggerGroup<ConfigType, AuthType, InputType>);
     polling(props: {
         intervalSeconds?: number;
         pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
-    }): SlateTriggerGroupBuilder<ConfigType, AuthType>;
-    webhook<UserConfigSchema extends z.ZodType<any> = z.ZodType<any>, FullConfigSchema extends z.ZodType<any> = z.ZodType<any>>(props: {
+    }): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
+    webhook<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>>(props: {
         autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
         manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema, FullConfigSchema>;
         process: SlateWebhookProcessHandler;
-    }): SlateTriggerGroupBuilder<ConfigType, AuthType>;
-    routingMatchers(handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>): SlateTriggerGroupBuilder<ConfigType, AuthType>;
-    build(): SlateTriggerGroup<ConfigType, AuthType>;
+    }): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
+    routingMatchers(handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
+    build(): SlateTriggerGroup<ConfigType, AuthType, InputType>;
 }
-declare let triggerGroup: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters) => SlateTriggerGroupBuilder<ConfigType, AuthType>;
+declare let triggerGroup: <ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters<InputType>) => SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
 
 type SlateActionType = 'tool' | 'trigger';
 interface SlateActionScopeClause {
@@ -805,7 +812,7 @@ declare class SlateTrigger<ConfigType extends {}, AuthType extends {}, InputType
     #private;
     private constructor();
     static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"trigger", ConfigType, AuthType, {}, {}, SlateTrigger<any, any, any, any>, false>;
-    get triggerGroup(): SlateTriggerGroup<ConfigType, AuthType>;
+    get triggerGroup(): SlateTriggerGroup<ConfigType, AuthType, Record<string, unknown>>;
     get matches(): SlateTriggerMatchesHandler;
     get map(): SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
 }
@@ -1048,7 +1055,7 @@ declare class Slate<ConfigType extends {}, AuthType extends {}> {
     get spec(): SlateSpecification<ConfigType, AuthType>;
     get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
     get adapters(): SlateAdapter<ConfigType, AuthType>[];
-    get triggerGroups(): SlateTriggerGroup<ConfigType, AuthType>[];
+    get triggerGroups(): SlateTriggerGroup<ConfigType, AuthType, Record<string, unknown>>[];
 }
 
 declare const graphWebhookHttp: {

package/dist/index.d.ts

@@ -149,6 +149,7 @@ type SlateAuthWithOauth<InputType extends {}, OutputType extends {
         description?: string;
         scope: string;
     }[];
+    adapters?: string[];
     docs?: SlateAuthDocsReference[];
     inputSchema?: z.ZodType<InputType>;
     onInputChanged?: (params: {
@@ -213,6 +214,7 @@ type SlateAuthWithToken<InputType extends {}, OutputType extends {
     type: 'auth.token';
     name: string;
     key: string;
+    adapters?: string[];
     inputSchema?: z.ZodType<InputType>;
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
@@ -242,6 +244,7 @@ type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> =
     type: 'auth.service_account';
     name: string;
     key: string;
+    adapters?: string[];
     inputSchema?: z.ZodType<InputType>;
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
@@ -271,6 +274,7 @@ type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
     type: 'auth.custom';
     name: string;
     key: string;
+    adapters?: string[];
     inputSchema?: z.ZodType<InputType>;
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
@@ -523,6 +527,7 @@ type SlateWebhookTargetListHandler<ConfigType extends {}, AuthType extends {}> =
 }>) => Promise<{
     targets: SlateWebhookTarget[];
     nextPageToken: any | null;
+    isPartial?: boolean;
 }>;
 type SlateWebhookRegisterHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     webhookTargetIdentifier: string;
@@ -536,18 +541,18 @@ type SlateWebhookUnregisterHandler<ConfigType extends {}, AuthType extends {}> =
     webhookRegistrationIdentifier: string;
     webhookRegistrationPayload: any;
 }>) => Promise<unknown>;
-type SlateWebhookManualSetupHandler<FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> = (context: SlateContext<{}, {}, {
+type SlateWebhookManualSetupHandler<FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> = (context: SlateContext<{}, {}, {
     webhookUrl: string;
 }>) => Promise<{
     webhookSetupDocument: string;
-    partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
+    partialWebhookRegistrationPayload: Partial<z$1.infer<FullConfigSchema>>;
 }>;
-type SlateWebhookManualFinishHandler<UserConfigSchema extends z.ZodType<any> = z.ZodType<any>, FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> = (context: SlateContext<{}, {}, {
+type SlateWebhookManualFinishHandler<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> = (context: SlateContext<{}, {}, {
     webhookUrl: string;
-    partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
-    userWebhookRegistrationPayload: z.infer<UserConfigSchema>;
+    partialWebhookRegistrationPayload: Partial<z$1.infer<FullConfigSchema>>;
+    userWebhookRegistrationPayload: z$1.infer<UserConfigSchema>;
 }>) => Promise<{
-    webhookRegistrationPayload: z.infer<FullConfigSchema>;
+    webhookRegistrationPayload: z$1.infer<FullConfigSchema>;
 }>;
 type SlateWebhookProcessHandler = (context: SlateContext<{}, {}, {
     request: Request;
@@ -569,7 +574,7 @@ interface SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType extends
     webhookRegister: SlateWebhookRegisterHandler<ConfigType, AuthType>;
     webhookUnregister: SlateWebhookUnregisterHandler<ConfigType, AuthType>;
 }
-interface SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema extends z.ZodType<any> = z.ZodType<any>, FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> {
+interface SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> {
     userConfigSchema: UserConfigSchema;
     fullConfigSchema: FullConfigSchema;
     setup: SlateWebhookManualSetupHandler<FullConfigSchema>;
@@ -580,52 +585,54 @@ interface SlateTriggerGroupWebhookParameters<ConfigType extends {}, AuthType ext
     manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<any, any>;
     process: SlateWebhookProcessHandler;
 }
-interface SlateTriggerGroupCreateParameters {
+interface SlateTriggerGroupCreateParameters<InputType extends {} = Record<string, unknown>> {
     key: string;
     name: string;
     description?: string;
     metadata?: Record<string, any>;
+    eventSchema?: z$1.ZodType<InputType>;
 }
-interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}> extends SlateTriggerGroupCreateParameters {
+interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> extends SlateTriggerGroupCreateParameters<InputType> {
     source: 'polling' | 'webhook';
     polling?: SlateTriggerGroupPollingParameters<ConfigType, AuthType>;
     webhook?: SlateTriggerGroupWebhookParameters<ConfigType, AuthType>;
     routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
 }
-declare class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}> {
+declare class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> {
     private readonly _spec;
     private readonly _params;
     private constructor();
-    static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters): SlateTriggerGroupBuilder<ConfigType, AuthType>;
+    static create<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters<InputType>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
     get spec(): SlateSpecification<ConfigType, AuthType>;
     get key(): string;
     get name(): string;
     get description(): string | undefined;
     get metadata(): Record<string, any> | undefined;
+    get eventSchema(): z$1.ZodType<InputType, unknown, z$1.core.$ZodTypeInternals<InputType, unknown>>;
     get source(): "polling" | "webhook";
     get polling(): SlateTriggerGroupPollingParameters<ConfigType, AuthType> | undefined;
     get webhook(): SlateTriggerGroupWebhookParameters<ConfigType, AuthType> | undefined;
     get routingMatchers(): SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
 }
-declare class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}> {
+declare class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> {
     #private;
     private readonly spec;
     private readonly params;
     private readonly factory;
-    constructor(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters, factory: (params: SlateTriggerGroupParameters<ConfigType, AuthType>) => SlateTriggerGroup<ConfigType, AuthType>);
+    constructor(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters<InputType>, factory: (params: SlateTriggerGroupParameters<ConfigType, AuthType, InputType>) => SlateTriggerGroup<ConfigType, AuthType, InputType>);
     polling(props: {
         intervalSeconds?: number;
         pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
-    }): SlateTriggerGroupBuilder<ConfigType, AuthType>;
-    webhook<UserConfigSchema extends z.ZodType<any> = z.ZodType<any>, FullConfigSchema extends z.ZodType<any> = z.ZodType<any>>(props: {
+    }): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
+    webhook<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>>(props: {
         autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
         manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema, FullConfigSchema>;
         process: SlateWebhookProcessHandler;
-    }): SlateTriggerGroupBuilder<ConfigType, AuthType>;
-    routingMatchers(handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>): SlateTriggerGroupBuilder<ConfigType, AuthType>;
-    build(): SlateTriggerGroup<ConfigType, AuthType>;
+    }): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
+    routingMatchers(handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
+    build(): SlateTriggerGroup<ConfigType, AuthType, InputType>;
 }
-declare let triggerGroup: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters) => SlateTriggerGroupBuilder<ConfigType, AuthType>;
+declare let triggerGroup: <ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters<InputType>) => SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
 
 type SlateActionType = 'tool' | 'trigger';
 interface SlateActionScopeClause {
@@ -805,7 +812,7 @@ declare class SlateTrigger<ConfigType extends {}, AuthType extends {}, InputType
     #private;
     private constructor();
     static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters): SlateActionBuilder<"trigger", ConfigType, AuthType, {}, {}, SlateTrigger<any, any, any, any>, false>;
-    get triggerGroup(): SlateTriggerGroup<ConfigType, AuthType>;
+    get triggerGroup(): SlateTriggerGroup<ConfigType, AuthType, Record<string, unknown>>;
     get matches(): SlateTriggerMatchesHandler;
     get map(): SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
 }
@@ -1048,7 +1055,7 @@ declare class Slate<ConfigType extends {}, AuthType extends {}> {
     get spec(): SlateSpecification<ConfigType, AuthType>;
     get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
     get adapters(): SlateAdapter<ConfigType, AuthType>[];
-    get triggerGroups(): SlateTriggerGroup<ConfigType, AuthType>[];
+    get triggerGroups(): SlateTriggerGroup<ConfigType, AuthType, Record<string, unknown>>[];
 }
 
 declare const graphWebhookHttp: {

package/dist/index.module.js

@@ -1136,6 +1136,7 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
 var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
 
 // src/action/triggerGroup.ts
+import { z as z2 } from "zod";
 var SlateDefaultPollingIntervalSeconds = 60 * 10;
 var SlateTriggerGroup = class _SlateTriggerGroup {
   constructor(_spec, _params) {
@@ -1162,6 +1163,9 @@ var SlateTriggerGroup = class _SlateTriggerGroup {
   get metadata() {
     return this._params.metadata;
   }
+  get eventSchema() {
+    return this._params.eventSchema ?? z2.object({}).passthrough();
+  }
   get source() {
     return this._params.source;
   }
@@ -2735,7 +2739,7 @@ var Slate = class _Slate {
 };
 
 // src/specification/specification.ts
-import z2 from "zod";
+import z3 from "zod";
 var SlateSpecification = class _SlateSpecification {
   constructor(_config, _auth, _params) {
     this._config = _config;
@@ -2752,7 +2756,7 @@ var SlateSpecification = class _SlateSpecification {
     return this._config.configSchema;
   }
   get authSchema() {
-    return "outputSchema" in this._auth ? this._auth.outputSchema : z2.object({});
+    return "outputSchema" in this._auth ? this._auth.outputSchema : z3.object({});
   }
   get config() {
     return this._config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.23",
+  "version": "1.0.0-rc.25",
   "publishConfig": {
     "access": "public"
   },
@@ -43,4 +43,4 @@
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

package/src/action/triggerGroup.ts

@@ -1,7 +1,7 @@
-import type z from 'zod';
+import { z } from 'zod';
+import type { SlateContext } from '../context';
 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;
@@ -19,9 +19,10 @@ export interface SlateWebhookTarget {
   targetOwnership: SlateWebhookTargetOwnership;
 }
 
-export type SlateTriggerGroupRoutingMatchersHandler<ConfigType extends {}, AuthType extends {}> = (
-  context: SlateContext<ConfigType, AuthType, {}>
-) => Promise<SlateTriggerRoutingMatcher[]>;
+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 }>
@@ -35,6 +36,8 @@ export type SlateWebhookTargetListHandler<ConfigType extends {}, AuthType extend
 ) => Promise<{
   targets: SlateWebhookTarget[];
   nextPageToken: any | null;
+  // Set when targets were skipped for a limit rather than exhausted by pagination.
+  isPartial?: boolean;
 }>;
 
 export type SlateWebhookRegisterHandler<ConfigType extends {}, AuthType extends {}> = (
@@ -63,13 +66,12 @@ export type SlateWebhookUnregisterHandler<ConfigType extends {}, AuthType extend
   >
 ) => 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 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>,
@@ -106,7 +108,10 @@ export type SlateWebhookProcessHandler = (
   response?: Response | SlateWebhookHttpResponseInit;
 }>;
 
-export interface SlateTriggerGroupPollingParameters<ConfigType extends {}, AuthType extends {}> {
+export interface SlateTriggerGroupPollingParameters<
+  ConfigType extends {},
+  AuthType extends {}
+> {
   intervalSeconds: number;
   pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
 }
@@ -130,36 +135,53 @@ export interface SlateTriggerGroupWebhookManualRegistrationParameters<
   finish?: SlateWebhookManualFinishHandler<UserConfigSchema, FullConfigSchema>;
 }
 
-export interface SlateTriggerGroupWebhookParameters<ConfigType extends {}, AuthType extends {}> {
+export interface SlateTriggerGroupWebhookParameters<
+  ConfigType extends {},
+  AuthType extends {}
+> {
   autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
   manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<any, any>;
   process: SlateWebhookProcessHandler;
 }
 
-export interface SlateTriggerGroupCreateParameters {
+export interface SlateTriggerGroupCreateParameters<
+  InputType extends {} = Record<string, unknown>
+> {
   key: string;
   name: string;
   description?: string;
   metadata?: Record<string, any>;
+  eventSchema?: z.ZodType<InputType>;
 }
 
-export interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}>
-  extends SlateTriggerGroupCreateParameters {
+export interface SlateTriggerGroupParameters<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {} = Record<string, unknown>
+> extends SlateTriggerGroupCreateParameters<InputType> {
   source: 'polling' | 'webhook';
   polling?: SlateTriggerGroupPollingParameters<ConfigType, AuthType>;
   webhook?: SlateTriggerGroupWebhookParameters<ConfigType, AuthType>;
   routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
 }
 
-export class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}> {
+export class SlateTriggerGroup<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {} = Record<string, unknown>
+> {
   private constructor(
     private readonly _spec: SlateSpecification<ConfigType, AuthType>,
-    private readonly _params: SlateTriggerGroupParameters<ConfigType, AuthType>
+    private readonly _params: SlateTriggerGroupParameters<ConfigType, AuthType, InputType>
   ) {}
 
-  static create<ConfigType extends {}, AuthType extends {}>(
+  static create<
+    ConfigType extends {},
+    AuthType extends {},
+    InputType extends {} = Record<string, unknown>
+  >(
     spec: SlateSpecification<ConfigType, AuthType>,
-    params: SlateTriggerGroupCreateParameters
+    params: SlateTriggerGroupCreateParameters<InputType>
   ) {
     return new SlateTriggerGroupBuilder(spec, params, p => new SlateTriggerGroup(spec, p));
   }
@@ -184,6 +206,10 @@ export class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}> {
     return this._params.metadata;
   }
 
+  get eventSchema() {
+    return this._params.eventSchema ?? (z.object({}).passthrough() as z.ZodType<InputType>);
+  }
+
   get source() {
     return this._params.source;
   }
@@ -201,24 +227,29 @@ export class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}> {
   }
 }
 
-export class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}> {
+export class SlateTriggerGroupBuilder<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {} = Record<string, unknown>
+> {
   #source: 'polling' | 'webhook' | null = null;
   #polling: SlateTriggerGroupPollingParameters<ConfigType, AuthType> | null = null;
   #webhook: SlateTriggerGroupWebhookParameters<ConfigType, AuthType> | null = null;
-  #routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType> | null = null;
+  #routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType> | null =
+    null;
 
   constructor(
     private readonly spec: SlateSpecification<ConfigType, AuthType>,
-    private readonly params: SlateTriggerGroupCreateParameters,
+    private readonly params: SlateTriggerGroupCreateParameters<InputType>,
     private readonly factory: (
-      params: SlateTriggerGroupParameters<ConfigType, AuthType>
-    ) => SlateTriggerGroup<ConfigType, AuthType>
+      params: SlateTriggerGroupParameters<ConfigType, AuthType, InputType>
+    ) => SlateTriggerGroup<ConfigType, AuthType, InputType>
   ) {}
 
   polling(props: {
     intervalSeconds?: number;
     pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
-  }): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+  }): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType> {
     if (this.#source) {
       throw new SlateDeclarationError('Trigger group invocation is already defined');
     }
@@ -236,13 +267,16 @@ export class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}
     UserConfigSchema extends z.ZodType<any> = z.ZodType<any>,
     FullConfigSchema extends z.ZodType<any> = z.ZodType<any>
   >(props: {
-    autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
+    autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<
+      ConfigType,
+      AuthType
+    >;
     manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<
       UserConfigSchema,
       FullConfigSchema
     >;
     process: SlateWebhookProcessHandler;
-  }): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+  }): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType> {
     if (this.#source) {
       throw new SlateDeclarationError('Trigger group invocation is already defined');
     }
@@ -265,12 +299,12 @@ export class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}
 
   routingMatchers(
     handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>
-  ): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+  ): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType> {
     this.#routingMatchers = handler;
     return this;
   }
 
-  build(): SlateTriggerGroup<ConfigType, AuthType> {
+  build(): SlateTriggerGroup<ConfigType, AuthType, InputType> {
     if (!this.#source) {
       throw new SlateDeclarationError(
         'Trigger group invocation (polling or webhook) is not defined'
@@ -290,7 +324,11 @@ export class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}
   }
 }
 
-export let triggerGroup = <ConfigType extends {}, AuthType extends {}>(
+export let triggerGroup = <
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {} = Record<string, unknown>
+>(
   spec: SlateSpecification<ConfigType, AuthType>,
-  params: SlateTriggerGroupCreateParameters
+  params: SlateTriggerGroupCreateParameters<InputType>
 ) => SlateTriggerGroup.create(spec, params);

package/src/auth/types.ts

@@ -22,6 +22,8 @@ export type SlateAuthWithOauth<
     scope: string;
   }[];
 
+  adapters?: string[];
+
   docs?: SlateAuthDocsReference[];
 
   inputSchema?: z.ZodType<InputType>;
@@ -92,6 +94,8 @@ export type SlateAuthWithToken<InputType extends {}, OutputType extends { token?
   name: string;
   key: string;
 
+  adapters?: string[];
+
   inputSchema?: z.ZodType<InputType>;
 
   docs?: SlateAuthDocsReference[];
@@ -124,6 +128,8 @@ export type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends
   name: string;
   key: string;
 
+  adapters?: string[];
+
   inputSchema?: z.ZodType<InputType>;
 
   docs?: SlateAuthDocsReference[];
@@ -156,6 +162,8 @@ export type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}>
   name: string;
   key: string;
 
+  adapters?: string[];
+
   inputSchema?: z.ZodType<InputType>;
 
   docs?: SlateAuthDocsReference[];

package/src/specification/slate.test.ts

@@ -97,6 +97,9 @@ describe('Slate.create', () => {
       triggerGroups: [manual, auto]
     });
 
-    expect(slate.triggerGroups.map(group => group.key)).toEqual(['manual_group', 'auto_group']);
+    expect(slate.triggerGroups.map(group => group.key)).toEqual([
+      'manual_group',
+      'auto_group'
+    ]);
   });
 });