@prismatic-io/spectral
Version:
Utility library for building Prismatic connectors and code-native integrations
682 lines (681 loc) • 29 kB
TypeScript
/**
* This module contains functions to help custom component and code-native
* integration authors create inputs, actions, components, and integrations
* that can run on the Prismatic platform.
*/
import { convertComponent } from "./serverTypes/convertComponent";
import { convertIntegration } from "./serverTypes/convertIntegration";
import type { ActionDefinition, ActionPerformReturn, ComponentDefinition, ComponentManifest, ConfigPage, ConfigVarResultCollection, ConnectionConfigVar, CustomerActivatedConnectionConfigVar, DataSourceConfigVar, DataSourceDefinition, DataSourceType, DefaultConnectionDefinition, Flow, InputFieldDefinition, Inputs, IntegrationDefinition, OAuth2ConnectionDefinition, OnPremConnectionDefinition, OrganizationActivatedConnectionConfigVar, StandardConfigVar, TriggerDefinition, TriggerPayload, TriggerResult } from "./types";
import type { PollingTriggerDefinition } from "./types/PollingTriggerDefinition";
/**
* This function creates a code-native integration object that can be
* imported into Prismatic.
*
* @param definition An IntegrationDefinition type object.
* @returns This function returns an integration object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/code-native/ | Code-Native Integrations}
* @example
* import { integration } from "@prismatic-io/spectral";
* import flows from "./flows";
* import { configPages } from "./configPages";
* import { componentRegistry } from "./componentRegistry";
*
* export default integration({
* name: "Acme Integration",
* description: "Syncs data between Acme and your system",
* category: "Communication",
* labels: ["chat", "beta"],
* iconPath: "icon.png",
* version: "1.0.0",
* flows,
* configPages,
* componentRegistry,
* });
*/
export declare const integration: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, T extends IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult> = IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>>(definition: T) => ReturnType<typeof convertIntegration<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>>;
/**
* This function creates a flow object for use in code-native integrations.
*
* @param definition A Flow type object.
* @returns This function returns a flow object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/code-native/flows/ | Code-Native Flows}
* @example
* // A webhook-triggered flow
* import { flow } from "@prismatic-io/spectral";
*
* export const myFlow = flow({
* name: "Process Webhook",
* stableKey: "process-webhook",
* description: "Receives and processes incoming webhooks",
* onTrigger: async (context, payload, params) => {
* return Promise.resolve({ payload });
* },
* onExecution: async (context, params) => {
* const { logger, configVars } = context;
* const triggerData = params.onTrigger.results;
* logger.info("Processing webhook payload");
* return Promise.resolve({ data: triggerData });
* },
* });
*
* @example
* // A scheduled flow with cron expression
* import { flow } from "@prismatic-io/spectral";
*
* export const scheduledSync = flow({
* name: "Nightly Sync",
* stableKey: "nightly-sync",
* description: "Syncs data every night at midnight",
* schedule: { value: "0 0 * * *", timezone: "America/Chicago" },
* onExecution: async (context, params) => {
* context.logger.info(`Sync started at ${new Date().toISOString()}`);
* return Promise.resolve({ data: null });
* },
* });
*/
export declare const flow: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, TTriggerPayload extends TriggerPayload = TriggerPayload, T extends Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload> = Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload>>(definition: T) => T;
/**
* This function creates a config wizard page object for use in code-native
* integrations.
*
* @param definition A Config Page type object.
* @returns This function returns a config page object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/code-native/config-wizard/ | Code-Native Config Wizard}
* @example
* import { configPage, connectionConfigVar, configVar } from "@prismatic-io/spectral";
*
* export const configPages = {
* Connections: configPage({
* tagline: "Set up your API connections",
* elements: {
* "Acme Connection": connectionConfigVar({
* stableKey: "acme-connection",
* dataType: "connection",
* inputs: {
* apiKey: { label: "API Key", type: "password", required: true },
* baseUrl: { label: "Base URL", type: "string", required: true },
* },
* }),
* },
* }),
* Configuration: configPage({
* tagline: "Configure sync settings",
* elements: {
* "Sync Interval": configVar({
* stableKey: "sync-interval",
* dataType: "picklist",
* pickList: ["hourly", "daily", "weekly"],
* defaultValue: "daily",
* }),
* },
* }),
* };
*/
export declare const configPage: <T extends ConfigPage = ConfigPage>(definition: T) => T;
/**
* This function creates a config variable object for code-native integrations.
*
* @param definition A Config Var type object.
* @returns This function returns a standard config var object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/code-native/config-wizard/#other-config-variable-types-in-code-native-integrations | Config Variable Types}
* @example
* import { configVar } from "@prismatic-io/spectral";
*
* // String config variable
* const endpoint = configVar({
* stableKey: "api-endpoint",
* dataType: "string",
* defaultValue: "https://api.example.com",
* description: "The base URL of the API",
* });
*
* @example
* import { configVar } from "@prismatic-io/spectral";
*
* // Picklist config variable
* const region = configVar({
* stableKey: "region",
* dataType: "picklist",
* pickList: ["us-east-1", "us-west-2", "eu-west-1"],
* defaultValue: "us-east-1",
* description: "AWS region to use",
* });
*
* @example
* import { configVar } from "@prismatic-io/spectral";
*
* // Boolean config variable
* const enableDebug = configVar({
* stableKey: "enable-debug",
* dataType: "boolean",
* defaultValue: false,
* description: "Enable debug logging",
* });
*
* @example
* import { configVar } from "@prismatic-io/spectral";
*
* // Schedule config variable
* const syncSchedule = configVar({
* stableKey: "sync-schedule",
* dataType: "schedule",
* description: "When to run the sync",
* timeZone: "America/Chicago",
* });
*/
export declare const configVar: <T extends StandardConfigVar>(definition: T) => T;
/**
* This function creates a data source-backed config variable for code-native
* integrations.
*
* @param definition A Data Source Config Var type object.
* @returns This function returns a data source config var object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/code-native/config-wizard/#data-sources-is-code-native-integrations | Data Sources in Code-Native}
* @example
* import { dataSourceConfigVar } from "@prismatic-io/spectral";
*
* const selectRepository = dataSourceConfigVar({
* stableKey: "select-repo",
* dataSourceType: "picklist",
* description: "Choose a repository from GitHub",
* perform: async (context, params) => {
* // Fetch repos from an API and return them as picklist options
* return { result: ["repo-1", "repo-2", "repo-3"] };
* },
* });
*/
export declare const dataSourceConfigVar: <TDataSourceConfigVar extends DataSourceConfigVar>(definition: TDataSourceConfigVar) => TDataSourceConfigVar;
/**
* This function creates a connection config variable for code-native
* integrations.
*
* @param definition A Connection Config Var type object.
* @returns This function returns a connection config var object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/code-native/config-wizard/#connections-in-code-native-integrations | Connections in Code-Native}
* @example
* import { connectionConfigVar } from "@prismatic-io/spectral";
* import { acmeConnection } from "./connections";
*
* const myConnection = connectionConfigVar({
* stableKey: "acme-connection",
* ...acmeConnection,
* });
*
* @example
* import { connectionConfigVar } from "@prismatic-io/spectral";
*
* // Inline connection definition
* const myApiConnection = connectionConfigVar({
* stableKey: "my-api-connection",
* dataType: "connection",
* inputs: {
* apiKey: { label: "API Key", type: "password", required: true },
* baseUrl: {
* label: "Base URL",
* type: "string",
* required: true,
* default: "https://api.example.com",
* },
* },
* });
*/
export declare const connectionConfigVar: <T extends ConnectionConfigVar = ConnectionConfigVar>(definition: T) => T;
/**
* This function creates a customer-activated connection for code-native
* integrations. Customer-activated connections are configured by end-users
* and can be shared across multiple integrations.
*
* @param definition A Customer-Activated Connection Config Var type object.
* @returns This function returns a connection config var object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/connections/integration-agnostic-connections/customer-activated/ | Customer-Activated Connections}
* @example
* import { customerActivatedConnection } from "@prismatic-io/spectral";
*
* const sharedSlackConnection = customerActivatedConnection({
* stableKey: "shared-slack-connection",
* });
*/
export declare const customerActivatedConnection: <T extends {
stableKey: string;
}>(definition: T) => CustomerActivatedConnectionConfigVar;
/**
* This function creates an org-activated connection for code-native
* integrations. Org-activated connections are configured once by the
* organization and shared across all customer instances.
*
* @param definition An Organization-Activated Connection Config Var type object.
* @returns This function returns a connection config var object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/connections/integration-agnostic-connections/org-activated-customer/ | Org-Activated Connections}
* @example
* import { organizationActivatedConnection } from "@prismatic-io/spectral";
*
* const orgSlackConnection = organizationActivatedConnection({
* stableKey: "org-slack-connection",
* });
*/
export declare const organizationActivatedConnection: <T extends {
stableKey: string;
}>(definition: T) => OrganizationActivatedConnectionConfigVar;
/**
* Generate a manifest of components that this code-native integration relies on.
* Component manifests allow your code-native integration to reference actions,
* triggers, connections, and data sources from published Prismatic components.
*
* @param definition A Component Manifest type object.
* @returns This function returns a component manifest object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/integrations/code-native/existing-components/ | Using Existing Components}
* @example
* import { componentManifest } from "@prismatic-io/spectral";
*
* const slack = componentManifest({
* key: "slack",
* public: true,
* actions: {
* postMessage: {
* inputs: {
* message: { label: "Message" },
* channelName: { label: "Channel Name" },
* },
* },
* },
* });
*/
export declare const componentManifest: <T extends ComponentManifest>(definition: T) => T;
/**
* This function creates a component object that can be
* imported into the Prismatic API.
*
* @param definition A ComponentDefinition type object, including display information, unique key, and a set of actions the component implements.
* @returns This function returns a component object that has the shape the Prismatic API expects.
* @see {@link https://prismatic.io/docs/custom-connectors/ | Custom Connectors}
* @example
* import { component } from "@prismatic-io/spectral";
* import actions from "./actions";
* import triggers from "./triggers";
* import connections from "./connections";
*
* export default component({
* key: "acme-connector",
* display: {
* label: "Acme",
* description: "Interact with Acme's API",
* iconPath: "icon.png",
* },
* actions,
* triggers,
* connections,
* });
*/
export declare const component: <TPublic extends boolean, TKey extends string>(definition: ComponentDefinition<TPublic, TKey>) => ReturnType<typeof convertComponent>;
/**
* This function creates an action object that can be referenced
* by a custom component. It helps ensure that the shape of the
* action object conforms to what the Prismatic API expects.
*
* @param definition An ActionDefinition type object that includes UI display information, a function to perform when the action is invoked, and an object containing inputs for the perform function.
* @returns This function validates the shape of the `definition` object provided, and returns the same action object.
* @see {@link https://prismatic.io/docs/custom-connectors/actions/ | Writing Custom Actions}
* @example
* import { action, input, util } from "@prismatic-io/spectral";
*
* const listItems = action({
* display: {
* label: "List Items",
* description: "Retrieve a list of items from Acme",
* },
* inputs: {
* connection: input({ label: "Connection", type: "connection", required: true }),
* limit: input({
* label: "Limit",
* type: "string",
* required: false,
* default: "100",
* comments: "Maximum number of items to return",
* }),
* },
* perform: async (context, { connection, limit }) => {
* const maxItems = util.types.toInt(limit, 100);
* context.logger.info(`Fetching up to ${maxItems} items`);
* // Make API call using connection...
* return { data: { items: [] } };
* },
* });
*/
export declare const action: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>>(definition: ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>) => ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>;
/**
* This function creates a trigger object that can be referenced
* by a custom component. It helps ensure that the shape of the
* trigger object conforms to what the Prismatic API expects.
*
* @param definition A TriggerDefinition type object that includes UI display information, a function to perform when the trigger is invoked, and an object containing inputs for the perform function.
* @returns This function validates the shape of the `definition` object provided, and returns the same trigger object.
* @see {@link https://prismatic.io/docs/custom-connectors/triggers/ | Writing Custom Triggers}
* @example
* import { trigger, input } from "@prismatic-io/spectral";
* import { HttpResponse } from "@prismatic-io/spectral";
*
* const webhookTrigger = trigger({
* display: {
* label: "Acme Webhook",
* description: "Receives webhooks from Acme",
* },
* inputs: {
* secret: input({
* label: "Signing Secret",
* type: "password",
* required: true,
* comments: "Used to verify webhook signatures",
* }),
* },
* scheduleSupport: "invalid",
* synchronousResponseSupport: "valid",
* perform: async (context, payload, { secret }) => {
* // Validate and process the incoming webhook
* const response: HttpResponse = {
* statusCode: 200,
* contentType: "application/json",
* body: JSON.stringify({ received: true }),
* };
* return Promise.resolve({
* payload,
* response,
* });
* },
* });
*/
export declare const trigger: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>>(definition: TriggerDefinition<TInputs, TConfigVars, TAllowsBranching, TResult>) => TriggerDefinition<TInputs, TConfigVars, TAllowsBranching, TResult>;
/**
* This function creates a polling trigger object that can be referenced
* by a custom component. A polling trigger runs on a schedule and uses
* `context.polling` to track state between invocations, enabling detection
* of new or changed records.
*
* @param definition A PollingTriggerDefinition, similar to a TriggerDefinition, except it requires a pollAction instead of a perform. The pollAction, which can be any action defined in the component, will be polled on the defined schedule.
* @see {@link https://prismatic.io/docs/custom-connectors/triggers/#app-event-polling-triggers | Polling Triggers}
* @returns This function validates the shape of the `definition` object provided, and returns the same polling trigger object.
* @example
* import { pollingTrigger, input } from "@prismatic-io/spectral";
*
* const newRecordsTrigger = pollingTrigger({
* display: {
* label: "New Records",
* description: "Triggers when new records are detected",
* },
* inputs: {
* connection: input({ label: "Connection", type: "connection", required: true }),
* },
* perform: async (context, payload, params) => {
* const lastCursor = context.polling.getState()["cursor"] ?? "";
* // Fetch records since lastCursor...
* const newRecords = []; // results from API
* context.polling.setState({ cursor: "new-cursor-value" });
* return Promise.resolve({
* payload: {
* ...payload,
* body: { data: newRecords },
* },
* });
* },
* });
*/
export declare const pollingTrigger: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TPayload extends TriggerPayload, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching, TPayload>, TActionInputs extends Inputs>(definition: PollingTriggerDefinition<TInputs, TConfigVars, TPayload, TAllowsBranching, TResult, TActionInputs>) => PollingTriggerDefinition<TInputs, TConfigVars, TPayload, TAllowsBranching, TResult, TActionInputs>;
/**
* This function creates a data source object that can be referenced
* by a custom component. It helps ensure that the shape of the
* data source object conforms to what the Prismatic API expects.
*
* @param definition A DataSourceDefinition type object that includes UI display information, a function to perform when the data source is invoked, and an object containing inputs for the perform function.
* @returns This function validates the shape of the `definition` object provided, and returns the same data source object.
* @see {@link https://prismatic.io/docs/custom-connectors/data-sources/ | Writing Custom Data Sources}
* @example
* import { dataSource, input } from "@prismatic-io/spectral";
*
* const selectChannel = dataSource({
* display: {
* label: "Select Channel",
* description: "Fetches a list of channels from the API",
* },
* dataSourceType: "picklist",
* inputs: {
* connection: input({ label: "Connection", type: "connection", required: true }),
* },
* perform: async (context, { connection }) => {
* // Fetch channels from API using the connection...
* return {
* result: [
* { label: "General", value: "C123" },
* { label: "Engineering", value: "C456" },
* ],
* };
* },
* });
*/
export declare const dataSource: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TDataSourceType extends DataSourceType>(definition: DataSourceDefinition<TInputs, TConfigVars, TDataSourceType>) => DataSourceDefinition<TInputs, TConfigVars, TDataSourceType>;
/**
* This function creates an input definition for a custom component action,
* trigger, or data source. Inputs define what information is collected from
* the user when configuring an integration step.
*
* @param definition An InputFieldDefinition object that describes the type of an input for a custom component action or trigger, and information on how it should be displayed in the Prismatic WebApp.
* @see {@link https://prismatic.io/docs/custom-connectors/actions/#action-inputs | Action Inputs}
* @returns This function validates the shape of the `definition` object provided, and returns the same input object.
* @example
* import { input } from "@prismatic-io/spectral";
*
* // A basic string input
* const itemName = input({
* label: "Item Name",
* type: "string",
* required: true,
* comments: "The name of the item to create",
* example: "My New Item",
* });
*
* @example
* import { input } from "@prismatic-io/spectral";
*
* // A string input with a dropdown of preset choices
* const priority = input({
* label: "Priority",
* type: "string",
* required: true,
* model: [
* { label: "Low", value: "low" },
* { label: "Medium", value: "medium" },
* { label: "High", value: "high" },
* ],
* default: "medium",
* });
*
* @example
* import { input } from "@prismatic-io/spectral";
*
* // A code input for JSON
* const requestBody = input({
* label: "Request Body",
* type: "code",
* language: "json",
* required: false,
* comments: "JSON body to send with the request",
* });
*
* @example
* import { input } from "@prismatic-io/spectral";
*
* // A key-value list collection input
* const headers = input({
* label: "HTTP Headers",
* type: "string",
* collection: "keyvaluelist",
* required: false,
* comments: "Additional headers to include in the request",
* });
*/
export declare const input: <T extends InputFieldDefinition>(definition: T) => T;
/**
* This function creates a connection that can be used by a code-native integration
* or custom component. Connections define the fields (API keys, tokens, etc.) needed
* to authenticate with a third-party service.
*
* @param definition A DefaultConnectionDefinition object that describes the type of a connection for a custom component action or trigger, and information on how it should be displayed in the Prismatic WebApp.
* @see {@link https://prismatic.io/docs/custom-connectors/connections/ | Writing Custom Connections}
* @returns This function validates the shape of the `definition` object provided and returns the same connection object.
* @example
* import { connection } from "@prismatic-io/spectral";
*
* const apiKeyConnection = connection({
* key: "apiKey",
* display: {
* label: "Acme API Key",
* description: "Authenticate with Acme using an API key",
* },
* inputs: {
* apiKey: {
* label: "API Key",
* type: "password",
* required: true,
* comments: "Generate an API key from your Acme dashboard",
* },
* baseUrl: {
* label: "Base URL",
* type: "string",
* required: true,
* default: "https://api.acme.com/v2",
* },
* },
* });
*/
export declare const connection: <T extends DefaultConnectionDefinition>(definition: T) => T;
/**
* This function creates an on-prem connection for a code-native integration or custom component.
* On-prem connections include `host` and `port` fields that are automatically overridden by the
* on-prem agent with local tunnel endpoints.
*
* @param definition An OnPremConnectionDefinition object that describes the type of a connection for a custom component action or trigger, and information on how it should be displayed in the Prismatic WebApp.
* @see {@link https://prismatic.io/docs/integrations/connections/on-prem-agent/#supporting-on-prem-connections-in-a-custom-connector | On-Prem Connections}
* @returns This function validates the shape of the `definition` object provided and returns the same connection object.
* @example
* import { onPremConnection } from "@prismatic-io/spectral";
*
* const databaseConnection = onPremConnection({
* key: "onPremDatabase",
* display: {
* label: "On-Prem Database",
* description: "Connect to an on-premise database through the Prismatic agent",
* },
* inputs: {
* host: {
* label: "Host",
* type: "string",
* required: true,
* onPremControlled: true,
* comments: "Overridden when on-prem is enabled",
* },
* port: {
* label: "Port",
* type: "string",
* required: true,
* onPremControlled: true,
* default: "5432",
* },
* username: {
* label: "Username",
* type: "string",
* required: true,
* },
* password: {
* label: "Password",
* type: "password",
* required: true,
* },
* },
* });
*/
export declare const onPremConnection: <T extends OnPremConnectionDefinition>(definition: T) => T;
/**
* This function creates an OAuth 2.0 connection for a code-native integration or custom component.
* Supports both Authorization Code and Client Credentials grant types.
*
* @param definition An OAuth2ConnectionDefinition object that describes the type of a connection for a custom component action or trigger, and information on how it should be displayed in the Prismatic WebApp.
* @see {@link https://prismatic.io/docs/custom-connectors/connections/#writing-oauth-20-connections | OAuth 2.0 Connections}
* @returns This function validates the shape of the `definition` object provided and returns the same connection object.
* @example
* import { oauth2Connection, OAuth2Type } from "@prismatic-io/spectral";
*
* // Authorization Code OAuth 2.0 connection
* const acmeOAuth = oauth2Connection({
* key: "acmeOAuth",
* display: {
* label: "Acme OAuth 2.0",
* description: "Authenticate with Acme using OAuth 2.0",
* },
* oauth2Type: OAuth2Type.AuthorizationCode,
* inputs: {
* authorizeUrl: {
* label: "Authorize URL",
* type: "string",
* required: true,
* default: "https://app.acme.com/oauth2/authorize",
* shown: false,
* },
* tokenUrl: {
* label: "Token URL",
* type: "string",
* required: true,
* default: "https://app.acme.com/oauth2/token",
* shown: false,
* },
* scopes: {
* label: "Scopes",
* type: "string",
* required: true,
* default: "read write",
* comments: "Space-delimited OAuth 2.0 permission scopes",
* },
* clientId: {
* label: "Client ID",
* type: "string",
* required: true,
* },
* clientSecret: {
* label: "Client Secret",
* type: "password",
* required: true,
* },
* },
* });
*/
export declare const oauth2Connection: <T extends OAuth2ConnectionDefinition>(definition: T) => T;
/**
* Register multiple component manifests for a code-native integration.
* Each manifest declares a published Prismatic component and the specific
* actions, triggers, connections, and data sources your integration uses.
*
* @param definition A record of Component Manifest objects keyed by component name.
* @returns This function returns the same record of component manifests.
* @see {@link https://prismatic.io/docs/integrations/code-native/existing-components/ | Using Existing Components}
* @example
* import { componentManifests } from "@prismatic-io/spectral";
*
* export const componentRegistry = componentManifests({
* slack: {
* key: "slack",
* public: true,
* actions: {
* postMessage: { inputs: { message: { label: "Message" } } },
* },
* },
* dropbox: {
* key: "dropbox",
* public: true,
* actions: {
* uploadFile: { inputs: { filePath: { label: "File Path" } } },
* },
* },
* });
*/
export declare const componentManifests: <T extends Record<string, ComponentManifest>>(definition: T) => T;
export * from "./errors";
export { default as testing } from "./testing";
export * from "./types";
export { default as util } from "./util";