@slates/proto 1.0.0-rc.2 → 1.0.0-rc.21

package/src/messages/triggerGroup.ts

@@ -0,0 +1,383 @@
+import z from 'zod';
+import {
+  slatesTriggerGroup,
+  slatesTriggerRoutingMatcher,
+  slatesWebhookTarget
+} from '../types';
+import { slatesWebhookHttpResponse } from './action';
+import { withRequestTraces } from './tracing';
+
+let slatesTriggerGroupWebhookEvent = z.object({
+  matchers: z.array(slatesTriggerRoutingMatcher),
+  payload: z.record(z.string(), z.any()),
+  idempotencyKey: z.string().optional(),
+  triggerIds: z.array(z.string())
+});
+
+let slatesTriggerGroupPollEvent = z.object({
+  payload: z.record(z.string(), z.any()),
+  idempotencyKey: z.string().optional(),
+  triggerIds: z.array(z.string())
+});
+
+/**
+ * List Trigger Groups
+ */
+export let slatesMessageTriggerGroupsListRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_groups.list'),
+  id: z.string(),
+  params: z.object({})
+});
+
+export type SlatesMessageTriggerGroupsListRequest = z.infer<
+  typeof slatesMessageTriggerGroupsListRequest
+>;
+
+export let slatesMessageTriggerGroupsListResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    triggerGroups: z.array(slatesTriggerGroup)
+  })
+});
+
+export type SlatesMessageTriggerGroupsListResponse = z.infer<
+  typeof slatesMessageTriggerGroupsListResponse
+>;
+
+/**
+ * Get Trigger Group
+ */
+export let slatesMessageTriggerGroupGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.get'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string()
+  })
+});
+
+export type SlatesMessageTriggerGroupGetRequest = z.infer<
+  typeof slatesMessageTriggerGroupGetRequest
+>;
+
+export let slatesMessageTriggerGroupGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    triggerGroup: slatesTriggerGroup
+  })
+});
+
+export type SlatesMessageTriggerGroupGetResponse = z.infer<
+  typeof slatesMessageTriggerGroupGetResponse
+>;
+
+/**
+ * List Webhook Targets
+ */
+export let slatesMessageTriggerGroupWebhookTargetsListRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.webhook.targets_list'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string(),
+    pageToken: z.any().nullable().optional()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookTargetsListRequest = z.infer<
+  typeof slatesMessageTriggerGroupWebhookTargetsListRequest
+>;
+
+export let slatesMessageTriggerGroupWebhookTargetsListResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    targets: z.array(slatesWebhookTarget),
+    nextPageToken: z.any().nullable(),
+    isPartial: z.boolean().optional()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookTargetsListResponse = z.infer<
+  typeof slatesMessageTriggerGroupWebhookTargetsListResponse
+>;
+
+/**
+ * Register Webhook
+ */
+export let slatesMessageTriggerGroupWebhookRegisterRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.webhook.register'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string(),
+    webhookTargetIdentifier: z.string(),
+    webhookTargetPayload: z.any(),
+    webhookUrl: z.string()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookRegisterRequest = z.infer<
+  typeof slatesMessageTriggerGroupWebhookRegisterRequest
+>;
+
+export let slatesMessageTriggerGroupWebhookRegisterResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    webhookRegistrationIdentifier: z.string(),
+    webhookRegistrationPayload: z.any()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookRegisterResponse = z.infer<
+  typeof slatesMessageTriggerGroupWebhookRegisterResponse
+>;
+
+/**
+ * Unregister Webhook
+ */
+export let slatesMessageTriggerGroupWebhookUnregisterRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.webhook.unregister'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string(),
+    webhookRegistrationIdentifier: z.string(),
+    webhookRegistrationPayload: z.any()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookUnregisterRequest = z.infer<
+  typeof slatesMessageTriggerGroupWebhookUnregisterRequest
+>;
+
+export let slatesMessageTriggerGroupWebhookUnregisterResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({})
+});
+
+export type SlatesMessageTriggerGroupWebhookUnregisterResponse = z.infer<
+  typeof slatesMessageTriggerGroupWebhookUnregisterResponse
+>;
+
+/**
+ * Manual Webhook Setup
+ */
+export let slatesMessageTriggerGroupWebhookManualSetupRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.webhook.manual_setup'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string(),
+    webhookUrl: z.string()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookManualSetupRequest = z.infer<
+  typeof slatesMessageTriggerGroupWebhookManualSetupRequest
+>;
+
+export let slatesMessageTriggerGroupWebhookManualSetupResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: z.object({
+    webhookSetupDocument: z.string(),
+    partialWebhookRegistrationPayload: z.any()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookManualSetupResponse = z.infer<
+  typeof slatesMessageTriggerGroupWebhookManualSetupResponse
+>;
+
+/**
+ * Manual Webhook Finish
+ */
+export let slatesMessageTriggerGroupWebhookManualFinishRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.webhook.manual_finish'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string(),
+    webhookUrl: z.string(),
+    partialWebhookRegistrationPayload: z.any(),
+    userWebhookRegistrationPayload: z.any()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookManualFinishRequest = z.infer<
+  typeof slatesMessageTriggerGroupWebhookManualFinishRequest
+>;
+
+export let slatesMessageTriggerGroupWebhookManualFinishResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    webhookRegistrationPayload: z.any()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookManualFinishResponse = z.infer<
+  typeof slatesMessageTriggerGroupWebhookManualFinishResponse
+>;
+
+/**
+ * Process Webhook Request
+ */
+export let slatesMessageTriggerGroupWebhookProcessRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.webhook.process'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string(),
+    url: z.string(),
+    method: z.string(),
+    headers: z.record(z.string(), z.string()),
+    body: z
+      .object({
+        encoding: z.literal('base64'),
+        content: z.string()
+      })
+      .nullable(),
+    webhookRegistrationPayload: z.any()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookProcessRequest = z.infer<
+  typeof slatesMessageTriggerGroupWebhookProcessRequest
+>;
+
+export let slatesMessageTriggerGroupWebhookProcessResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    events: z.array(slatesTriggerGroupWebhookEvent),
+    response: slatesWebhookHttpResponse.nullable().optional()
+  })
+});
+
+export type SlatesMessageTriggerGroupWebhookProcessResponse = z.infer<
+  typeof slatesMessageTriggerGroupWebhookProcessResponse
+>;
+
+/**
+ * Get Routing Matchers
+ */
+export let slatesMessageTriggerGroupRoutingMatchersGetRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.routing_matchers.get'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string()
+  })
+});
+
+export type SlatesMessageTriggerGroupRoutingMatchersGetRequest = z.infer<
+  typeof slatesMessageTriggerGroupRoutingMatchersGetRequest
+>;
+
+export let slatesMessageTriggerGroupRoutingMatchersGetResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    matchers: z.array(slatesTriggerRoutingMatcher)
+  })
+});
+
+export type SlatesMessageTriggerGroupRoutingMatchersGetResponse = z.infer<
+  typeof slatesMessageTriggerGroupRoutingMatchersGetResponse
+>;
+
+/**
+ * Poll
+ */
+export let slatesMessageTriggerGroupPollingPollRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/trigger_group.polling.poll'),
+  id: z.string(),
+  params: z.object({
+    triggerGroupId: z.string(),
+    state: z.any().nullable()
+  })
+});
+
+export type SlatesMessageTriggerGroupPollingPollRequest = z.infer<
+  typeof slatesMessageTriggerGroupPollingPollRequest
+>;
+
+export let slatesMessageTriggerGroupPollingPollResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    updatedState: z.any().nullable().optional(),
+    events: z.array(slatesTriggerGroupPollEvent)
+  })
+});
+
+export type SlatesMessageTriggerGroupPollingPollResponse = z.infer<
+  typeof slatesMessageTriggerGroupPollingPollResponse
+>;
+
+export type SlatesTriggerGroupRequests =
+  | SlatesMessageTriggerGroupsListRequest
+  | SlatesMessageTriggerGroupGetRequest
+  | SlatesMessageTriggerGroupWebhookTargetsListRequest
+  | SlatesMessageTriggerGroupWebhookRegisterRequest
+  | SlatesMessageTriggerGroupWebhookUnregisterRequest
+  | SlatesMessageTriggerGroupWebhookManualSetupRequest
+  | SlatesMessageTriggerGroupWebhookManualFinishRequest
+  | SlatesMessageTriggerGroupWebhookProcessRequest
+  | SlatesMessageTriggerGroupRoutingMatchersGetRequest
+  | SlatesMessageTriggerGroupPollingPollRequest;
+
+export type SlatesTriggerGroupResponses =
+  | SlatesMessageTriggerGroupsListResponse
+  | SlatesMessageTriggerGroupGetResponse
+  | SlatesMessageTriggerGroupWebhookTargetsListResponse
+  | SlatesMessageTriggerGroupWebhookRegisterResponse
+  | SlatesMessageTriggerGroupWebhookUnregisterResponse
+  | SlatesMessageTriggerGroupWebhookManualSetupResponse
+  | SlatesMessageTriggerGroupWebhookManualFinishResponse
+  | SlatesMessageTriggerGroupWebhookProcessResponse
+  | SlatesMessageTriggerGroupRoutingMatchersGetResponse
+  | SlatesMessageTriggerGroupPollingPollResponse;
+
+export let slatesTriggerGroupResponsesByMethod = {
+  'slates/trigger_groups.list': slatesMessageTriggerGroupsListResponse,
+  'slates/trigger_group.get': slatesMessageTriggerGroupGetResponse,
+  'slates/trigger_group.webhook.targets_list':
+    slatesMessageTriggerGroupWebhookTargetsListResponse,
+  'slates/trigger_group.webhook.register': slatesMessageTriggerGroupWebhookRegisterResponse,
+  'slates/trigger_group.webhook.unregister':
+    slatesMessageTriggerGroupWebhookUnregisterResponse,
+  'slates/trigger_group.webhook.manual_setup':
+    slatesMessageTriggerGroupWebhookManualSetupResponse,
+  'slates/trigger_group.webhook.manual_finish':
+    slatesMessageTriggerGroupWebhookManualFinishResponse,
+  'slates/trigger_group.webhook.process': slatesMessageTriggerGroupWebhookProcessResponse,
+  'slates/trigger_group.routing_matchers.get':
+    slatesMessageTriggerGroupRoutingMatchersGetResponse,
+  'slates/trigger_group.polling.poll': slatesMessageTriggerGroupPollingPollResponse
+};
+
+export let slatesTriggerGroupRequestsByMethod = {
+  'slates/trigger_groups.list': slatesMessageTriggerGroupsListRequest,
+  'slates/trigger_group.get': slatesMessageTriggerGroupGetRequest,
+  'slates/trigger_group.webhook.targets_list':
+    slatesMessageTriggerGroupWebhookTargetsListRequest,
+  'slates/trigger_group.webhook.register': slatesMessageTriggerGroupWebhookRegisterRequest,
+  'slates/trigger_group.webhook.unregister': slatesMessageTriggerGroupWebhookUnregisterRequest,
+  'slates/trigger_group.webhook.manual_setup':
+    slatesMessageTriggerGroupWebhookManualSetupRequest,
+  'slates/trigger_group.webhook.manual_finish':
+    slatesMessageTriggerGroupWebhookManualFinishRequest,
+  'slates/trigger_group.webhook.process': slatesMessageTriggerGroupWebhookProcessRequest,
+  'slates/trigger_group.routing_matchers.get':
+    slatesMessageTriggerGroupRoutingMatchersGetRequest,
+  'slates/trigger_group.polling.poll': slatesMessageTriggerGroupPollingPollRequest
+};

package/src/messages/webhookErrors.ts

@@ -0,0 +1,21 @@
+export let SLATES_WEBHOOK_ERROR_CODES = {
+  INVALID_SIGNATURE: 'webhook.invalid_signature',
+  INVALID_PAYLOAD: 'webhook.invalid_payload',
+  UNSUPPORTED_EVENT: 'webhook.unsupported_event',
+  DUPLICATE_DELIVERY: 'webhook.duplicate_delivery',
+  UNAUTHORIZED: 'webhook.unauthorized'
+} as const;
+
+export type SlatesWebhookErrorCode =
+  (typeof SLATES_WEBHOOK_ERROR_CODES)[keyof typeof SLATES_WEBHOOK_ERROR_CODES];
+
+export let SLATES_WEBHOOK_ERROR_DEFAULTS: Record<
+  SlatesWebhookErrorCode,
+  { status: number; retryable: boolean }
+> = {
+  [SLATES_WEBHOOK_ERROR_CODES.INVALID_SIGNATURE]: { status: 401, retryable: false },
+  [SLATES_WEBHOOK_ERROR_CODES.INVALID_PAYLOAD]: { status: 400, retryable: false },
+  [SLATES_WEBHOOK_ERROR_CODES.UNSUPPORTED_EVENT]: { status: 400, retryable: false },
+  [SLATES_WEBHOOK_ERROR_CODES.DUPLICATE_DELIVERY]: { status: 200, retryable: false },
+  [SLATES_WEBHOOK_ERROR_CODES.UNAUTHORIZED]: { status: 401, retryable: false }
+};

package/src/types/action.ts

@@ -1,5 +1,13 @@
 import z from 'zod';
 
+export let slatesActionScopeClause = z.object({
+  OR: z.array(z.string()).min(1)
+});
+
+export let slatesActionScopes = z.object({
+  AND: z.array(slatesActionScopeClause).min(1)
+});
+
 export let slatesActionBase = z.object({
   id: z.string(),
 
@@ -14,31 +22,34 @@ export let slatesActionBase = z.object({
     })
     .optional(),
   metadata: z.record(z.string(), z.any()).optional(),
+  scopes: slatesActionScopes.optional(),
+  authMethods: z.array(z.string()).optional(),
 
   inputSchema: z.record(z.string(), z.any()),
-  outputSchema: z.record(z.string(), z.any())
+  outputSchema: z.record(z.string(), z.any()),
+
+  docs: z.array(
+    z.object({
+      type: z.literal('docs.action.general').optional(),
+      name: z.string(),
+      url: z.string()
+    })
+  ),
+
+  adapter: z.optional(z.nullable(z.string()))
 });
 
 export let slatesActionTool = slatesActionBase.extend({
   type: z.literal('action.tool'),
-  capabilities: z.object({})
+  capabilities: z.object({}),
+  isPublic: z.boolean()
 });
 
 export let slatesActionTrigger = slatesActionBase.extend({
   type: z.literal('action.trigger'),
   capabilities: z.object({}),
 
-  invocation: z.union([
-    z.object({
-      type: z.literal('polling'),
-      intervalSeconds: z.number().min(15)
-    }),
-    z.object({
-      type: z.literal('webhook'),
-      autoRegistration: z.boolean(),
-      autoUnregistration: z.boolean()
-    })
-  ])
+  triggerGroupId: z.string()
 });
 
 export let slatesAction = z.union([slatesActionTool, slatesActionTrigger]);
@@ -46,3 +57,4 @@ export let slatesAction = z.union([slatesActionTool, slatesActionTrigger]);
 export type SlatesAction = z.infer<typeof slatesAction>;
 export type SlatesActionTool = z.infer<typeof slatesActionTool>;
 export type SlatesActionTrigger = z.infer<typeof slatesActionTrigger>;
+export type SlatesActionScopes = z.infer<typeof slatesActionScopes>;

package/src/types/adapter.ts

@@ -0,0 +1,15 @@
+import z from 'zod';
+
+export let slatesAdapter = z.object({
+  id: z.string(),
+  name: z.string(),
+
+  capabilities: z.array(
+    z.object({
+      id: z.string(),
+      value: z.any()
+    })
+  )
+});
+
+export type SlateAdapter = z.infer<typeof slatesAdapter>;

package/src/types/authMethod.ts

@@ -21,6 +21,8 @@ export let slatesAuthenticationMethod = z.object({
     )
     .optional(),
 
+  adapters: z.array(z.string()).optional(),
+
   inputSchema: z.record(z.string(), z.any()),
   outputSchema: z.record(z.string(), z.any()),
 
@@ -29,7 +31,23 @@ export let slatesAuthenticationMethod = z.object({
     handleChangedInput: z.object({ enabled: z.boolean() }).optional(),
     handleTokenRefresh: z.object({ enabled: z.boolean() }).optional(),
     getProfile: z.object({ enabled: z.boolean() }).optional()
-  })
+  }),
+
+  docs: z.array(
+    z.object({
+      type: z
+        .union([
+          z.literal('docs.auth.oauth'),
+          z.literal('docs.auth.oauth_scopes'),
+          z.literal('docs.auth.token'),
+          z.literal('docs.auth.service_account'),
+          z.literal('docs.auth.custom')
+        ])
+        .optional(),
+      name: z.string(),
+      url: z.string()
+    })
+  )
 });
 
 export type SlateAuthenticationMethod = z.infer<typeof slatesAuthenticationMethod>;

package/src/types/index.ts

@@ -1,3 +1,5 @@
 export * from './action';
+export * from './adapter';
 export * from './authMethod';
 export * from './participant';
+export * from './triggerGroup';

package/src/types/triggerGroup.ts

@@ -0,0 +1,49 @@
+import z from 'zod';
+
+export let slatesTriggerRoutingMatcher = z.record(z.string(), z.any());
+
+export let slatesTriggerGroupInvocation = z.union([
+  z.object({
+    type: z.literal('polling'),
+    intervalSeconds: z.number().min(60 * 10)
+  }),
+  z.object({
+    type: z.literal('webhook'),
+    registration: z.union([
+      z.object({
+        mode: z.literal('auto')
+      }),
+      z.object({
+        mode: z.literal('manual'),
+        userConfigSchema: z.record(z.string(), z.any()),
+        fullConfigSchema: z.record(z.string(), z.any())
+      })
+    ])
+  })
+]);
+
+export let slatesTriggerGroup = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+
+  invocation: slatesTriggerGroupInvocation
+});
+
+export let slatesWebhookTargetOwnership = z.enum(['single_user', 'multi_user']);
+
+export let slatesWebhookTarget = z.object({
+  webhookTargetIdentifier: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  metadata: z.record(z.string(), z.any()),
+  webhookTargetPayload: z.any(),
+  targetOwnership: slatesWebhookTargetOwnership
+});
+
+export type SlatesTriggerRoutingMatcher = z.infer<typeof slatesTriggerRoutingMatcher>;
+export type SlatesTriggerGroupInvocation = z.infer<typeof slatesTriggerGroupInvocation>;
+export type SlatesTriggerGroup = z.infer<typeof slatesTriggerGroup>;
+export type SlatesWebhookTargetOwnership = z.infer<typeof slatesWebhookTargetOwnership>;
+export type SlatesWebhookTarget = z.infer<typeof slatesWebhookTarget>;

package/src/version.ts

@@ -0,0 +1,3 @@
+export const SLATES_PROTOCOL_VERSION = 'slates@2026-01-01' as const;
+
+export type SlatesProtocolVersion = typeof SLATES_PROTOCOL_VERSION;

package/dist/handler/index.d.ts

@@ -1,2 +0,0 @@
-export * from './provider';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/handler/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/handler/provider.d.ts

@@ -1,46 +0,0 @@
-import { SlatesNotifications, SlatesRequests, SlatesResponsesByMethod } from '../messages';
-export declare class SlatesProviderProtoHandlerManager {
-    #private;
-    onNotification<Method extends SlatesNotifications['method']>(method: Method, handler: (message: Extract<SlatesNotifications, {
-        method: Method;
-    }>) => void): void;
-    onRequest<Method extends SlatesRequests['method']>(method: Method, cb: (message: Extract<SlatesRequests, {
-        method: Method;
-    }>) => Promise<SlatesResponsesByMethod[Method]['result']>): void;
-    private _handleInput;
-    static handleInput(manager: SlatesProviderProtoHandlerManager, input: SlatesNotifications | SlatesRequests): Promise<{
-        jsonrpc: "2.0";
-        id: any;
-        error: import("@lowerdeck/error").ErrorRecord<"bad_request", 400>;
-        result?: undefined;
-    } | {
-        jsonrpc: "2.0";
-        id: any;
-        error: import("@lowerdeck/error").ErrorRecord<string, number>;
-        result?: undefined;
-    } | {
-        jsonrpc: "2.0";
-        id: any;
-        error: import("@lowerdeck/error").ErrorRecord<"invalid_data", 400>;
-        result?: undefined;
-    } | {
-        jsonrpc: "2.0";
-        id: any;
-        result: any;
-        error?: undefined;
-    } | {
-        jsonrpc: "2.0";
-        id: any;
-        error: import("@lowerdeck/error").ServiceError<any>;
-        result?: undefined;
-    } | {
-        jsonrpc: "2.0";
-        id: any;
-        error: import("@lowerdeck/error").ErrorRecord<"internal_server_error", 500>;
-        result?: undefined;
-    } | undefined>;
-}
-export declare let createSlatesProviderProtoHandler: (cb: (manager: SlatesProviderProtoHandlerManager) => Promise<void>) => {
-    run: () => Promise<SlatesProviderProtoHandlerManager>;
-};
-//# sourceMappingURL=provider.d.ts.map

package/dist/handler/provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/handler/provider.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,mBAAmB,EAEnB,cAAc,EAEd,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAErB,qBAAa,iCAAiC;;IAU5C,cAAc,CAAC,MAAM,SAAS,mBAAmB,CAAC,QAAQ,CAAC,EACzD,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI;IAc9E,SAAS,CAAC,MAAM,SAAS,cAAc,CAAC,QAAQ,CAAC,EAC/C,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,CACF,OAAO,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,KACjD,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC;YAc3C,YAAY;WAmFb,WAAW,CACtB,OAAO,EAAE,iCAAiC,EAC1C,KAAK,EAAE,mBAAmB,GAAG,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI9C;AAED,eAAO,IAAI,gCAAgC,GACzC,IAAI,CAAC,OAAO,EAAE,iCAAiC,KAAK,OAAO,CAAC,IAAI,CAAC;;CASjE,CAAC"}