@slates/provider-handler 1.0.0-rc.3 → 1.0.0-rc.32

package/src/pQueue.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { resolveDefaultExport } from './pQueue';
+
+class Example {
+  value: number;
+  constructor(value: number) {
+    this.value = value;
+  }
+}
+
+describe('resolveDefaultExport', () => {
+  it('unwraps nested CJS default exports from bundlers', () => {
+    expect(resolveDefaultExport<typeof Example>({ default: { default: Example } })).toBe(
+      Example
+    );
+    expect(new (resolveDefaultExport<typeof Example>({ default: Example }))(3).value).toBe(3);
+  });
+});

package/src/pQueue.ts

@@ -0,0 +1,18 @@
+import PQueueImport from 'p-queue';
+
+export let resolveDefaultExport = <T>(value: unknown): T => {
+  let current = value;
+
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === 'function') return current as T;
+    if (current && typeof current === 'object' && 'default' in current) {
+      current = (current as { default: unknown }).default;
+      continue;
+    }
+    break;
+  }
+
+  throw new TypeError('Module export is not a constructor');
+};
+
+export let PQueue = resolveDefaultExport<typeof PQueueImport>(PQueueImport);

package/src/spec.test.ts

@@ -0,0 +1,83 @@
+import { isServiceError } from '@lowerdeck/error';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { getMappableAction, getTriggersForGroup, isMappableTrigger, mapAction } from './spec';
+
+let baseAction = {
+  key: 'do_thing',
+  name: 'Do Thing',
+  description: 'desc',
+  instructions: undefined,
+  constraints: undefined,
+  tags: [],
+  metadata: {},
+  scopes: [],
+  authMethods: [],
+  docs: [],
+  adapter: undefined,
+  inputSchema: z.object({}),
+  outputSchema: z.object({})
+};
+
+let toolAction: any = { ...baseAction, type: 'tool', isPublic: false };
+
+let validTriggerGroup = { key: 'my_group', name: 'My Group' };
+let validTrigger: any = {
+  ...baseAction,
+  type: 'trigger',
+  triggerGroup: validTriggerGroup,
+  matches: () => true,
+  map: () => ({})
+};
+
+let incompatibleTrigger: any = { ...baseAction, type: 'trigger', triggerGroup: undefined };
+
+describe('isMappableTrigger', () => {
+  it('is true for tool actions', () => {
+    expect(isMappableTrigger(toolAction)).toBe(true);
+  });
+
+  it('is true for triggers with a trigger group', () => {
+    expect(isMappableTrigger(validTrigger)).toBe(true);
+  });
+
+  it('is false for triggers missing a trigger group', () => {
+    expect(isMappableTrigger(incompatibleTrigger)).toBe(false);
+  });
+});
+
+describe('mapAction', () => {
+  it('maps a well-formed trigger', () => {
+    let mapped = mapAction({} as any, validTrigger);
+    expect(mapped).toMatchObject({ type: 'action.trigger', triggerGroupId: 'my_group' });
+  });
+});
+
+describe('getTriggersForGroup', () => {
+  it('filters out triggers missing a trigger group instead of throwing', () => {
+    let slate = { actions: [toolAction, validTrigger, incompatibleTrigger] } as any;
+
+    expect(getTriggersForGroup(slate, 'my_group')).toEqual([validTrigger]);
+    expect(getTriggersForGroup(slate, 'other_group')).toEqual([]);
+  });
+});
+
+describe('getMappableAction', () => {
+  it('returns tool and well-formed trigger actions', () => {
+    let slate = { actions: [toolAction, validTrigger] } as any;
+
+    expect(getMappableAction(slate, 'do_thing')).toBe(toolAction);
+  });
+
+  it('treats a trigger missing its group as not found instead of crashing', () => {
+    let slate = { actions: [incompatibleTrigger] } as any;
+
+    try {
+      getMappableAction(slate, 'do_thing');
+      expect.unreachable();
+    } catch (e) {
+      expect(isServiceError(e)).toBe(true);
+      expect((e as any).data.status).toBe(404);
+    }
+  });
+});

package/src/spec.ts

@@ -1,6 +1,16 @@
 import { badRequestError, notFoundError, ServiceError } from '@lowerdeck/error';
-import { SlateAuthenticationMethod, SlatesAction } from '@slates/proto';
-import { Slate, SlateDefaultPollingIntervalSeconds } from '@slates/provider';
+import type {
+  SlateAuthenticationMethod,
+  SlatesAction,
+  SlateAdapter as SlatesAdapter,
+  SlatesTriggerGroup
+} from '@slates/proto';
+import {
+  type Slate,
+  type SlateAdapter,
+  type SlateTrigger,
+  SlateDefaultPollingIntervalSeconds
+} from '@slates/provider';
 import z from 'zod';
 import { toJsonSchema } from './validation';
 
@@ -8,7 +18,7 @@ export let getAuthMethod = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   authenticationMethodId: string
 ) => {
-  let authMethod = slate.spec.auth.authStack.find(m => m.key == authenticationMethodId);
+  let authMethod = slate.spec.auth.authStack.find(m => m.key === authenticationMethodId);
   if (!authMethod) {
     throw new ServiceError(
       badRequestError({
@@ -49,14 +59,16 @@ export let mapAuthMethod = <ConfigType extends {}, AuthType extends {}>(
       enabled: !!m.onInputChanged
     },
     getProfile: { enabled: !!m.getProfile }
-  }
+  },
+
+  docs: m.docs ?? []
 });
 
 export let getAction = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   actionId: string
 ) => {
-  let action = slate.actions.find(m => m.key == actionId);
+  let action = slate.actions.find(m => m.key === actionId);
   if (!action) {
     throw new ServiceError(notFoundError(`action`, actionId));
   }
@@ -64,6 +76,26 @@ export let getAction = <ConfigType extends {}, AuthType extends {}>(
   return action;
 };
 
+export let getAdapter = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  adapterId: string
+) => {
+  let adapter = slate.adapters.find(m => m.id === adapterId);
+  if (!adapter) {
+    throw new ServiceError(notFoundError(`adapter`, adapterId));
+  }
+
+  return adapter;
+};
+
+export let mapAdapter = <ConfigType extends {}, AuthType extends {}>(
+  adapter: SlateAdapter<ConfigType, AuthType>
+): SlatesAdapter => ({
+  id: adapter.id,
+  name: adapter.name,
+  capabilities: adapter.capabilities
+});
+
 export let getActionWithType = <
   Type extends 'tool' | 'trigger',
   ConfigType extends {},
@@ -74,7 +106,7 @@ export let getActionWithType = <
   actionId: string
 ): ReturnType<typeof getAction<ConfigType, AuthType>> & { type: Type } => {
   let action = getAction(slate, actionId);
-  if (action.type != type) {
+  if (action.type !== type) {
     throw new ServiceError(
       badRequestError({
         message: `Action with ID ${actionId} is not of type ${type}`
@@ -86,7 +118,7 @@ export let getActionWithType = <
 };
 
 export let mapAction = <ConfigType extends {}, AuthType extends {}>(
-  slate: Slate<ConfigType, AuthType>,
+  _slate: Slate<ConfigType, AuthType>,
   a: ReturnType<typeof getAction<ConfigType, AuthType>>
 ): SlatesAction => {
   let base = {
@@ -97,16 +129,21 @@ export let mapAction = <ConfigType extends {}, AuthType extends {}>(
     constraints: a.constraints,
     tags: a.tags,
     metadata: a.metadata,
+    scopes: a.scopes,
+    authMethods: a.authMethods,
+    docs: a.docs ?? [],
+    ...(a.adapter ? { adapter: a.adapter } : {}),
 
     inputSchema: toJsonSchema(a.inputSchema),
     outputSchema: toJsonSchema(a.outputSchema)
   };
 
-  if (a.type == 'tool') {
+  if (a.type === 'tool') {
     return {
       ...base,
       type: 'action.tool',
-      capabilities: {}
+      capabilities: {},
+      isPublic: a.isPublic
     };
   }
 
@@ -114,17 +151,109 @@ export let mapAction = <ConfigType extends {}, AuthType extends {}>(
     ...base,
     type: 'action.trigger',
     capabilities: {},
-
-    invocation:
-      a.source == 'polling'
-        ? {
-            type: 'polling',
-            intervalSeconds: a.polling.intervalInSeconds ?? SlateDefaultPollingIntervalSeconds
-          }
-        : {
-            type: 'webhook',
-            autoRegistration: !!a.autoRegisterWebhook,
-            autoUnregistration: !!a.autoUnregisterWebhook
-          }
+    triggerGroupId: a.triggerGroup.key
   };
 };
+
+export let isMappableTrigger = <ConfigType extends {}, AuthType extends {}>(
+  action: Slate<ConfigType, AuthType>['actions'][number]
+): boolean => action.type !== 'trigger' || !!action.triggerGroup;
+
+export let getMappableAction = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  actionId: string
+) => {
+  let action = getAction(slate, actionId);
+  if (!isMappableTrigger(action)) {
+    throw new ServiceError(notFoundError(`action`, actionId));
+  }
+
+  return action;
+};
+
+export let getTriggerGroup = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  triggerGroupId: string
+) => {
+  let group = slate.triggerGroups.find(g => g.key === triggerGroupId);
+  if (!group) {
+    throw new ServiceError(notFoundError(`trigger_group`, triggerGroupId));
+  }
+
+  return group;
+};
+
+export let getTriggersForGroup = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  triggerGroupId: string
+): SlateTrigger<ConfigType, AuthType, any, any>[] =>
+  slate.actions.filter(
+    (action): action is SlateTrigger<ConfigType, AuthType, any, any> =>
+      action.type === 'trigger' && action.triggerGroup?.key === triggerGroupId
+  );
+
+export let evaluateTriggerMatches = <ConfigType extends {}, AuthType extends {}>(
+  slate: Slate<ConfigType, AuthType>,
+  triggerGroupId: string,
+  payload: unknown
+): string[] =>
+  getTriggersForGroup(slate, triggerGroupId)
+    .filter(trigger => trigger.matches(payload))
+    .map(trigger => trigger.key);
+
+export let getWebhookAutoRegistration = <ConfigType extends {}, AuthType extends {}>(
+  group: ReturnType<typeof getTriggerGroup<ConfigType, AuthType>>
+) => {
+  if (group.source !== 'webhook' || !group.webhook?.autoRegistration) {
+    throw new ServiceError(
+      badRequestError({
+        message: `Trigger group does not support webhook auto-registration: ${group.key}`
+      })
+    );
+  }
+
+  return group.webhook.autoRegistration;
+};
+
+export let getWebhookManualRegistration = <ConfigType extends {}, AuthType extends {}>(
+  group: ReturnType<typeof getTriggerGroup<ConfigType, AuthType>>
+) => {
+  if (group.source !== 'webhook' || !group.webhook?.manualRegistration) {
+    throw new ServiceError(
+      badRequestError({
+        message: `Trigger group does not support manual webhook registration: ${group.key}`
+      })
+    );
+  }
+
+  return group.webhook.manualRegistration;
+};
+
+export let mapTriggerGroup = <ConfigType extends {}, AuthType extends {}>(
+  group: ReturnType<typeof getTriggerGroup<ConfigType, AuthType>>
+): SlatesTriggerGroup => ({
+  id: group.key,
+  name: group.name,
+  description: group.description,
+  metadata: group.metadata,
+  invocation:
+    group.source === 'polling'
+      ? {
+          type: 'polling',
+          intervalSeconds: group.polling?.intervalSeconds ?? SlateDefaultPollingIntervalSeconds
+        }
+      : {
+          type: 'webhook',
+          registration: group.webhook?.manualRegistration
+            ? {
+                mode: 'manual',
+                userConfigSchema: toJsonSchema(
+                  group.webhook.manualRegistration.userConfigSchema
+                ),
+                fullConfigSchema: toJsonSchema(
+                  group.webhook.manualRegistration.fullConfigSchema
+                )
+              }
+            : { mode: 'auto' }
+        }
+});

package/src/validation.ts

@@ -1,5 +1,5 @@
 import { ServiceError, validationError } from '@lowerdeck/error';
-import z from 'zod';
+import type z from 'zod';
 
 export let zodToValidationError = (entity: string, message: string, e: z.ZodError) => {
   return validationError({

package/src/webhook.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import {
+  SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES,
+  serializeWebhookHttpResponse
+} from './webhook';
+
+describe('serializeWebhookHttpResponse', () => {
+  it('serializes a Response with status, headers, and body', async () => {
+    await expect(
+      serializeWebhookHttpResponse(
+        new Response('created', {
+          status: 201,
+          headers: {
+            'content-type': 'text/plain',
+            'x-webhook-result': 'accepted'
+          }
+        })
+      )
+    ).resolves.toEqual({
+      status: 201,
+      headers: {
+        'content-type': 'text/plain',
+        'x-webhook-result': 'accepted'
+      },
+      body: {
+        encoding: 'base64',
+        content: Buffer.from('created').toString('base64')
+      }
+    });
+  });
+
+  it('applies defaults to a plain response init', async () => {
+    await expect(serializeWebhookHttpResponse({ body: 'ok' })).resolves.toEqual({
+      status: 200,
+      headers: {},
+      body: {
+        encoding: 'base64',
+        content: Buffer.from('ok').toString('base64')
+      }
+    });
+  });
+
+  it('serializes binary response bodies without changing their bytes', async () => {
+    await expect(
+      serializeWebhookHttpResponse({
+        status: 202,
+        body: new Uint8Array([0, 127, 128, 255])
+      })
+    ).resolves.toMatchObject({
+      status: 202,
+      body: {
+        encoding: 'base64',
+        content: Buffer.from([0, 127, 128, 255]).toString('base64')
+      }
+    });
+  });
+
+  it('rejects bodies larger than one MiB', async () => {
+    await expect(
+      serializeWebhookHttpResponse({
+        body: new Uint8Array(SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES + 1)
+      })
+    ).rejects.toThrow('Webhook response body exceeds');
+  });
+});

package/src/webhook.ts

@@ -0,0 +1,69 @@
+import { badRequestError, ServiceError } from '@lowerdeck/error';
+import type { SlatesWebhookHttpResponse } from '@slates/proto';
+import type { SlateWebhookHttpResponseInit } from '@slates/provider';
+
+export let SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES = 1024 * 1024;
+
+let serializeBody = (body: Uint8Array | null): SlatesWebhookHttpResponse['body'] => {
+  if (body === null) return null;
+
+  if (body.byteLength > SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES) {
+    throw new ServiceError(
+      badRequestError({
+        message: `Webhook response body exceeds the ${SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES}-byte limit`
+      })
+    );
+  }
+
+  return {
+    encoding: 'base64',
+    content: Buffer.from(body).toString('base64')
+  };
+};
+
+let headersToObject = (headers: Headers) => {
+  let result: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+
+let validateStatus = (status: number) => {
+  if (!Number.isInteger(status) || status < 100 || status > 599) {
+    throw new ServiceError(
+      badRequestError({
+        message: 'Webhook response status must be an integer between 100 and 599'
+      })
+    );
+  }
+};
+
+export let serializeWebhookHttpResponse = async (
+  response: Response | SlateWebhookHttpResponseInit
+): Promise<SlatesWebhookHttpResponse> => {
+  if (response instanceof Response) {
+    validateStatus(response.status);
+    return {
+      status: response.status,
+      headers: headersToObject(response.headers),
+      body: serializeBody(
+        response.body === null ? null : new Uint8Array(await response.arrayBuffer())
+      )
+    };
+  }
+
+  let status = response.status ?? 200;
+  validateStatus(status);
+
+  let body =
+    typeof response.body === 'string'
+      ? new TextEncoder().encode(response.body)
+      : (response.body ?? null);
+
+  return {
+    status,
+    headers: response.headers ?? {},
+    body: serializeBody(body)
+  };
+};

package/dist/action/action.d.ts

@@ -1,90 +0,0 @@
-import { z } from 'zod';
-import { SlateContext } from '../context';
-import { SlateSpecification } from '../specification/specification';
-export type SlateActionType = 'tool' | 'trigger';
-export interface SlateActionParameters {
-    key: string;
-    name: string;
-    description?: string;
-    instructions?: string[];
-    constraints?: string[];
-    tags?: {
-        destructive?: boolean;
-        readOnly?: boolean;
-        [key: string]: boolean | undefined;
-    };
-}
-export type SlateToolInvocationHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
-    output: OutputType;
-    message: string;
-}>;
-export type SlateTriggerMappingHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
-    type: string;
-    id: string;
-    output: OutputType;
-}>;
-export type SlateTriggerPollingHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    state: any;
-}>) => Promise<{
-    inputs: InputType[];
-    updatedState?: any;
-}>;
-export type SlateTriggerWebhookRequestHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    request: Request;
-    state: any;
-}>) => Promise<{
-    inputs: InputType[];
-    updatedState?: any;
-}>;
-export type SlateTriggerWebhookAutoRegistrationHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    webhookBaseUrl: string;
-}>) => Promise<{
-    registrationDetails: any;
-}>;
-export type SlateTriggerWebhookAutoUnregistrationHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
-    webhookBaseUrl: string;
-    registrationDetails: any;
-}>) => Promise<unknown>;
-export interface SlateActionParametersTool<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
-    handlerInvocation: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
-}
-export interface SlatePollingOptions {
-    intervalInSeconds?: number;
-}
-export interface SlateActionParametersTrigger<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
-    source: 'polling' | 'webhook';
-    polling?: SlatePollingOptions;
-    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-    handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
-    pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
-    autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
-    autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
-}
-export type SlateActionParametersAny<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersTool<ConfigType, AuthType, InputType, OutputType> | SlateActionParametersTrigger<ConfigType, AuthType, InputType, OutputType>;
-export type SlateActionCreateParameters<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersAny<ConfigType, AuthType, InputType, OutputType> & SlateActionParameters & {
-    configSchema: z.ZodType<ConfigType>;
-    authSchema: z.ZodType<AuthType>;
-    inputSchema: z.ZodType<InputType>;
-    outputSchema: z.ZodType<OutputType>;
-};
-export declare abstract class SlateAction<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
-    readonly type: Type;
-    protected readonly _spec: SlateSpecification<ConfigType, AuthType>;
-    protected readonly _inputSchema: z.ZodType<InputType>;
-    protected readonly _outputSchema: z.ZodType<OutputType>;
-    protected readonly _params: SlateActionParameters;
-    constructor(type: Type, _spec: SlateSpecification<ConfigType, AuthType>, _inputSchema: z.ZodType<InputType>, _outputSchema: z.ZodType<OutputType>, _params: SlateActionParameters);
-    get configSchema(): z.ZodType<ConfigType, unknown, z.core.$ZodTypeInternals<ConfigType, unknown>>;
-    get inputSchema(): z.ZodType<InputType, unknown, z.core.$ZodTypeInternals<InputType, unknown>>;
-    get outputSchema(): z.ZodType<OutputType, unknown, z.core.$ZodTypeInternals<OutputType, unknown>>;
-    get parameters(): SlateActionParameters;
-    get key(): string;
-    get name(): string;
-    get description(): string | undefined;
-    get tags(): {
-        [key: string]: boolean | undefined;
-        destructive?: boolean;
-        readOnly?: boolean;
-    } | undefined;
-}
-//# sourceMappingURL=action.d.ts.map

package/dist/action/action.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/action/action.ts"],"names":[],"mappings":"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"}

package/dist/action/builder.d.ts

@@ -1,27 +0,0 @@
-import z from 'zod';
-import { SlateSpecification } from '../specification/specification';
-import { SlateAction, SlateActionCreateParameters, SlateActionParameters, SlateActionType, SlatePollingOptions, SlateToolInvocationHandler, SlateTriggerMappingHandler, SlateTriggerPollingHandler, SlateTriggerWebhookAutoRegistrationHandler, SlateTriggerWebhookAutoUnregistrationHandler, SlateTriggerWebhookRequestHandler } from './action';
-export declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> {
-    #private;
-    private readonly type;
-    private readonly spec;
-    private readonly params;
-    private readonly factory;
-    constructor(type: Type, spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters, factory: (params: SlateActionCreateParameters<any, any, any, any>) => SlateAction<Type, any, any, any, any>);
-    input<NewInputType extends {}>(schema: z.ZodType<NewInputType>): SlateActionBuilder<Type, ConfigType, AuthType, NewInputType, OutputType>;
-    output<NewOutputType extends {}>(schema: z.ZodType<NewOutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, NewOutputType>;
-    handleInvocation(handler: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType>;
-    webhook(props: {
-        handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-        handleRequest: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
-        autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
-        autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
-    }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType>;
-    polling(props: {
-        options?: SlatePollingOptions;
-        pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
-        handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-    }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType>;
-    build(): SlateAction<Type, ConfigType, AuthType, InputType, OutputType>;
-}
-//# sourceMappingURL=builder.d.ts.map

package/dist/action/builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/action/builder.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EACL,WAAW,EACX,2BAA2B,EAC3B,qBAAqB,EAGrB,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,0BAA0B,EAC1B,0BAA0B,EAC1B,0CAA0C,EAC1C,4CAA4C,EAC5C,iCAAiC,EAClC,MAAM,UAAU,CAAC;AAElB,qBAAa,kBAAkB,CAC7B,IAAI,SAAS,eAAe,EAC5B,UAAU,SAAS,EAAE,EACrB,QAAQ,SAAS,EAAE,EACnB,SAAS,SAAS,EAAE,EACpB,UAAU,SAAS,EAAE;;IAiBnB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAHP,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,kBAAkB,CAAC,UAAU,EAAE,QAAQ,CAAC,EAC9C,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,CACxB,MAAM,EAAE,2BAA2B,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,KACpD,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;IAM5C,KAAK,CAAC,YAAY,SAAS,EAAE,EAC3B,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,GAC9B,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,CAAC;IAW3E,MAAM,CAAC,aAAa,SAAS,EAAE,EAC7B,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,GAC/B,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,CAAC;IAW3E,gBAAgB,CACd,OAAO,EAAE,0BAA0B,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,GAC/E,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;IAYxE,OAAO,CAAC,KAAK,EAAE;QACb,WAAW,EAAE,0BAA0B,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACrF,aAAa,EAAE,iCAAiC,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QAClF,mBAAmB,CAAC,EAAE,0CAA0C,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACvF,qBAAqB,CAAC,EAAE,4CAA4C,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;KAC5F,GAAG,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;IAgBzE,OAAO,CAAC,KAAK,EAAE;QACb,OAAO,CAAC,EAAE,mBAAmB,CAAC;QAC9B,UAAU,CAAC,EAAE,0BAA0B,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QACzE,WAAW,EAAE,0BAA0B,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;KACtF,GAAG,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;IAezE,KAAK,IAuBG,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;CAEvE"}

package/dist/action/index.d.ts

@@ -1,5 +0,0 @@
-export * from './action';
-export * from './tool';
-export * from './trigger';
-export type * from './builder';
-//# sourceMappingURL=index.d.ts.map

package/dist/action/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/action/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAE1B,mBAAmB,WAAW,CAAC"}

package/dist/action/tool.d.ts

@@ -1,11 +0,0 @@
-import { SlateSpecification } from '../specification/specification';
-import { SlateAction, SlateActionParameters } from './action';
-import { SlateActionBuilder } from './builder';
-export interface SlateToolParameters extends SlateActionParameters {
-}
-export declare class SlateTool<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> extends SlateAction<'tool', ConfigType, AuthType, InputType, OutputType> {
-    private constructor();
-    static create<ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateToolParameters): SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}>;
-}
-export declare let tool: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateToolParameters) => SlateActionBuilder<"tool", ConfigType, AuthType, {}, {}>;
-//# sourceMappingURL=tool.d.ts.map

package/dist/action/tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/action/tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,WAAW,mBAAoB,SAAQ,qBAAqB;CAAG;AAErE,qBAAa,SAAS,CACpB,UAAU,SAAS,EAAE,EACrB,QAAQ,SAAS,EAAE,EACnB,SAAS,SAAS,EAAE,EACpB,UAAU,SAAS,EAAE,CACrB,SAAQ,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;IACxE,OAAO;IASP,MAAM,CAAC,MAAM,CAAC,UAAU,SAAS,EAAE,EAAE,QAAQ,SAAS,EAAE,EACtD,IAAI,EAAE,kBAAkB,CAAC,UAAU,EAAE,QAAQ,CAAC,EAC9C,MAAM,EAAE,mBAAmB;CAS9B;AAED,eAAO,IAAI,IAAI,GAAI,UAAU,SAAS,EAAE,EAAE,QAAQ,SAAS,EAAE,EAC3D,MAAM,kBAAkB,CAAC,UAAU,EAAE,QAAQ,CAAC,EAC9C,QAAQ,mBAAmB,6DACM,CAAC"}