@segment/actions-core 1.3.0-next.0

package/dist/cjs/create-request-client.d.ts

@@ -0,0 +1,5 @@
+import { ExtendOptions, Got } from 'got';
+/**
+ * Creates a Got client instance with Segment's default configuration + custom options
+ */
+export default function createRequestClient(...options: ExtendOptions[]): Got;

package/dist/cjs/create-request-client.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const got_1 = __importDefault(require("got"));
+/**
+ * Creates a Got client instance with Segment's default configuration + custom options
+ */
+function createRequestClient(...options) {
+    const defaultOptions = {
+        // disable automatic retries
+        retry: 0,
+        // default is no timeout
+        timeout: 5000,
+        headers: {
+            'user-agent': 'Segment'
+        }
+    };
+    const client = got_1.default.extend(defaultOptions, ...options);
+    return client;
+}
+exports.default = createRequestClient;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXJlcXVlc3QtY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NyZWF0ZS1yZXF1ZXN0LWNsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDhDQUE2QztBQUU3Qzs7R0FFRztBQUNILFNBQXdCLG1CQUFtQixDQUFDLEdBQUcsT0FBd0I7SUFDckUsTUFBTSxjQUFjLEdBQUc7UUFDckIsNEJBQTRCO1FBQzVCLEtBQUssRUFBRSxDQUFDO1FBQ1Isd0JBQXdCO1FBQ3hCLE9BQU8sRUFBRSxJQUFJO1FBQ2IsT0FBTyxFQUFFO1lBQ1AsWUFBWSxFQUFFLFNBQVM7U0FDeEI7S0FDRixDQUFBO0lBRUQsTUFBTSxNQUFNLEdBQUcsYUFBRyxDQUFDLE1BQU0sQ0FBQyxjQUFjLEVBQUUsR0FBRyxPQUFPLENBQUMsQ0FBQTtJQUNyRCxPQUFPLE1BQU0sQ0FBQTtBQUNmLENBQUM7QUFiRCxzQ0FhQyJ9

package/dist/cjs/dayjs.d.ts

@@ -0,0 +1,2 @@
+import dayjs from 'dayjs';
+export default dayjs;

package/dist/cjs/dayjs.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+dayjs_1.default.extend(utc_1.default);
+exports.default = dayjs_1.default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF5anMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF5anMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxrREFBeUI7QUFDekIsMkRBQWtDO0FBRWxDLGVBQUssQ0FBQyxNQUFNLENBQUMsYUFBRyxDQUFDLENBQUE7QUFFakIsa0JBQWUsZUFBSyxDQUFBIn0=

package/dist/cjs/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { JSONSchema4Type } from 'json-schema';
+export declare function defaultValues(fields: Record<string, unknown>): Record<string, JSONSchema4Type>;

package/dist/cjs/defaults.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultValues = void 0;
+function defaultValues(fields) {
+    const obj = {};
+    for (const field of Object.keys(fields)) {
+        const defaultValue = fields[field].default;
+        if (typeof defaultValue !== 'undefined') {
+            obj[field] = defaultValue;
+        }
+    }
+    return obj;
+}
+exports.defaultValues = defaultValues;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVmYXVsdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsU0FBZ0IsYUFBYSxDQUFDLE1BQStCO0lBQzNELE1BQU0sR0FBRyxHQUFvQyxFQUFFLENBQUE7SUFFL0MsS0FBSyxNQUFNLEtBQUssSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1FBQ3ZDLE1BQU0sWUFBWSxHQUFJLE1BQU0sQ0FBQyxLQUFLLENBQWlCLENBQUMsT0FBTyxDQUFBO1FBQzNELElBQUksT0FBTyxZQUFZLEtBQUssV0FBVyxFQUFFO1lBQ3ZDLEdBQUcsQ0FBQyxLQUFLLENBQUMsR0FBRyxZQUFZLENBQUE7U0FDMUI7S0FDRjtJQUVELE9BQU8sR0FBRyxDQUFBO0FBQ1osQ0FBQztBQVhELHNDQVdDIn0=

package/dist/cjs/destination-kit/action.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import Ajv from 'ajv';
+import { EventEmitter } from 'events';
+import { Got } from 'got';
+import { JSONLikeObject } from '../json-object';
+import { ExecuteInput, Step, StepResult, Steps } from './step';
+import type { InputField, RequestExtension } from './types';
+export declare type RequestFn<Settings, Payload> = (request: Got, data: ExecuteInput<Settings, Payload>) => any;
+export interface ActionDefinition<Settings, Payload = any> {
+    /** The unique identifier for the action, e.g. `postToChannel` */
+    /** The display title of the action */
+    title: string;
+    /** The display description of the action */
+    description: string;
+    /** Whether the action is recommended for quick setup */
+    recommended?: boolean;
+    /** An optional fql query that will be used to prepopulate the action when it is first set up */
+    defaultSubscription?: string;
+    /** Whether or not this action should be visible/configurable in the UI */
+    hidden?: boolean;
+    /**
+     * The fields used to perform the action. These fields should match what the partner API expects.
+     *
+     * This is a set of JSON Schema properties right now.
+     * We may eventually auto-generate the JSON Schema from a definition object
+     * instead of requiring devs to build and modify JSON Schema directly.
+     *
+     * Plus, JSON Schema cannot fully represent our action or field definitions
+     * without many custom keywords.
+     */
+    fields: Record<string, InputField>;
+    /**
+     * Temporary way to "register" autocomplete fields.
+     * This is likely going to change as we productionalize the data model and definition object
+     */
+    autocompleteFields?: {
+        [K in keyof Payload]?: RequestFn<Settings, Payload>;
+    };
+    /**
+     * Register fields that should be executed, cached and provided
+     * to the action's `perform` function
+     */
+    cachedFields?: {
+        [field: string]: {
+            key: (data: ExecuteInput<Settings, Payload>) => string;
+            ttl: number;
+            value: RequestFn<Settings, Payload>;
+            negative?: boolean;
+        };
+    };
+    /** The operation to perform when this action is triggered */
+    perform: RequestFn<Settings, Payload>;
+}
+export declare class Validate<Settings, Payload> extends Step<Settings, Payload> {
+    field: ExecuteInputField;
+    validate: Ajv.ValidateFunction;
+    constructor(field: ExecuteInputField, schema: object);
+    executeStep(data: ExecuteInput<Settings, Payload>): Promise<string>;
+}
+interface ExecuteAutocompleteInput<Settings, Payload> {
+    settings: Settings;
+    payload: Payload;
+    cachedFields: {
+        [key: string]: string;
+    };
+    page?: string;
+}
+declare type ExecuteInputField = 'payload' | 'settings';
+/**
+ * Action is the beginning step for all partner actions. Entrypoints always start with the
+ * MapAndValidateInput step.
+ */
+export declare class Action<Settings, Payload extends JSONLikeObject> extends EventEmitter {
+    readonly steps: Steps<Settings, Payload>;
+    private requestExtensions;
+    private autocompleteCache;
+    constructor(definition: ActionDefinition<Settings, Payload>, extendRequest?: RequestExtension<Settings, Payload>);
+    execute(data: ExecuteInput<Settings, Payload>): Promise<StepResult[]>;
+    executeAutocomplete(field: string, data: ExecuteAutocompleteInput<Settings, Payload>): any;
+    private loadDefinition;
+    private validatePayload;
+    private autocomplete;
+    private request;
+    private cachedRequest;
+}
+export {};

package/dist/cjs/destination-kit/action.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Action = exports.Validate = void 0;
+// @ts-ignore no types
+const ajv_human_errors_1 = require("@segment/ajv-human-errors");
+const ajv_1 = __importDefault(require("ajv"));
+const events_1 = require("events");
+const node_cache_1 = __importDefault(require("node-cache"));
+const create_request_client_1 = __importDefault(require("../create-request-client"));
+const get_1 = require("../get");
+const mapping_kit_1 = require("../mapping-kit");
+const fields_to_jsonschema_1 = require("./fields-to-jsonschema");
+const step_1 = require("./step");
+class MapInput extends step_1.Step {
+    executeStep(data) {
+        // Transforms the initial payload (event) + action settings (from `subscriptions[0].mapping`)
+        // into input data that the action can use to talk to partner apis
+        if (data.mapping) {
+            // Technically we can't know whether or not `transform` returns the exact shape of Payload here, hence the casting
+            // It will be validated in subsequent steps
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            data.payload = mapping_kit_1.transform(data.mapping, data.payload);
+        }
+        return Promise.resolve('MapInput completed');
+    }
+}
+class Validate extends step_1.Step {
+    constructor(field, schema) {
+        super();
+        this.field = field;
+        const ajv = new ajv_1.default({
+            // Coerce types to be a bit more liberal.
+            coerceTypes: true,
+            // Return all validation errors, not just the first.
+            allErrors: true,
+            // Include reference to schema and data in error values.
+            verbose: true,
+            // Use a more parse-able format for JSON paths.
+            jsonPointers: true
+        });
+        this.validate = ajv.compile(schema);
+    }
+    executeStep(data) {
+        if (!this.validate(data[this.field])) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            throw new ajv_human_errors_1.AggregateAjvError(this.validate.errors);
+        }
+        return Promise.resolve('Validate completed');
+    }
+}
+exports.Validate = Validate;
+/**
+ * Request handles delivering a payload to an external API. It uses the `got` library under the hood.
+ *
+ * The callback should be  able to return the raw request instead of needing to do `return response.data` etc.
+ */
+class Request extends step_1.Step {
+    constructor(extensions, requestFn) {
+        super();
+        this.extensions = extensions || [];
+        this.requestFn = requestFn;
+    }
+    async executeStep(data) {
+        if (!this.requestFn) {
+            return '';
+        }
+        const request = this.createRequestClient(data);
+        const response = await this.requestFn(request, data);
+        if (response === null) {
+            return 'TODO: null';
+        }
+        return response.body;
+    }
+    createRequestClient(data) {
+        const options = this.extensions.map((extension) => extension(data));
+        const client = create_request_client_1.default(...options).extend({
+            hooks: {
+                beforeError: [
+                    (error) => {
+                        // @ts-ignore the type is wrong in got
+                        const { response } = error;
+                        this.emit('response', response);
+                        return error;
+                    }
+                ],
+                afterResponse: [
+                    (response) => {
+                        this.emit('response', response);
+                        return response;
+                    }
+                ]
+            }
+        });
+        return client;
+    }
+}
+// CachedRequest is like Request but cached. Next question.
+class CachedRequest extends Request {
+    constructor(extensions, config) {
+        super(extensions);
+        this.keyFn = config.key;
+        this.valueFn = config.value;
+        this.as = config.as;
+        this.negative = config.negative || false;
+        this.cache = new node_cache_1.default({
+            stdTTL: config.ttl,
+            maxKeys: 1000
+        });
+    }
+    async executeStep(data) {
+        const k = this.keyFn(data);
+        let v = this.cache.get(k);
+        if (v !== undefined) {
+            data.cachedFields[this.as] = v;
+            return 'cache hit';
+        }
+        const request = this.createRequestClient(data);
+        try {
+            v = await this.valueFn(request, data);
+        }
+        catch (e) {
+            if (get_1.get(e, 'response.statusCode') === 404) {
+                v = undefined;
+            }
+            else {
+                throw e;
+            }
+        }
+        // Only cache if value is not negative *or* negative option is set. Negative caching is off by
+        // default because the common cases are: A) auth token generation, which should never be
+        // negative, and B) create-or-update patterns, where the resource should exist after the first
+        // negative value.
+        if ((v !== null && v !== undefined) || this.negative) {
+            this.cache.set(k, v);
+        }
+        return 'cache miss';
+    }
+}
+/**
+ * Action is the beginning step for all partner actions. Entrypoints always start with the
+ * MapAndValidateInput step.
+ */
+class Action extends events_1.EventEmitter {
+    constructor(definition, extendRequest) {
+        super();
+        this.steps = new step_1.Steps();
+        const step = new MapInput();
+        this.steps.push(step);
+        this.autocompleteCache = {};
+        this.requestExtensions = [];
+        if (extendRequest) {
+            // This must come before we load the definition because
+            // it instantiates "steps" with whatever request extensions
+            // are defined at that moment in time
+            this.requestExtensions.push(extendRequest);
+        }
+        this.loadDefinition(definition);
+    }
+    async execute(data) {
+        const results = await this.steps.execute(data);
+        const finalResult = results[results.length - 1];
+        if (finalResult.error) {
+            throw finalResult.error;
+        }
+        return results;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    executeAutocomplete(field, data) {
+        if (!this.autocompleteCache[field]) {
+            return {
+                data: [],
+                pagination: {}
+            };
+        }
+        const step = new Request(this.requestExtensions, this.autocompleteCache[field]);
+        return step.executeStep(data);
+    }
+    loadDefinition(definition) {
+        var _a, _b;
+        if (definition.fields) {
+            this.validatePayload(definition.fields);
+        }
+        Object.entries((_a = definition.autocompleteFields) !== null && _a !== void 0 ? _a : {}).forEach(([field, callback]) => {
+            this.autocomplete(field, callback);
+        });
+        Object.entries((_b = definition.cachedFields) !== null && _b !== void 0 ? _b : {}).forEach(([field, cacheConfig]) => {
+            this.cachedRequest({
+                ...cacheConfig,
+                as: field
+            });
+        });
+        if (definition.perform) {
+            this.request(definition.perform);
+        }
+    }
+    validatePayload(fields) {
+        const step = new Validate('payload', fields_to_jsonschema_1.fieldsToJsonSchema(fields));
+        this.steps.push(step);
+    }
+    autocomplete(field, callback) {
+        this.autocompleteCache[field] = callback;
+    }
+    request(requestFn) {
+        const step = new Request(this.requestExtensions, requestFn);
+        step.on('response', (response) => this.emit('response', response));
+        this.steps.push(step);
+    }
+    cachedRequest(config) {
+        const step = new CachedRequest(this.requestExtensions, config);
+        this.steps.push(step);
+    }
+}
+exports.Action = Action;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/destination-kit/fields-to-jsonschema.d.ts

@@ -0,0 +1,4 @@
+import { JSONSchema4 } from 'json-schema';
+import type { InputField } from './types';
+export declare function fieldsToJsonSchema(fields?: Record<string, InputField>): JSONSchema4;
+export declare function jsonSchemaToFields(schema?: JSONSchema4): Record<string, InputField>;

package/dist/cjs/destination-kit/fields-to-jsonschema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaToFields = exports.fieldsToJsonSchema = void 0;
+function fieldsToJsonSchema(fields = {}) {
+    const required = [];
+    const properties = {};
+    for (const key of Object.keys(fields)) {
+        const field = fields[key];
+        // Remove the `required` property from fields because it'll get lifted up into an array of required keys
+        properties[key] = Object.assign({}, field);
+        delete properties[key].required;
+        // Grab all the field keys with `required: true`
+        if (field.required) {
+            required.push(key);
+        }
+    }
+    return {
+        $schema: 'http://json-schema.org/schema#',
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required
+    };
+}
+exports.fieldsToJsonSchema = fieldsToJsonSchema;
+function jsonSchemaToFields(schema = {}) {
+    var _a, _b;
+    const requiredFields = (_a = schema.required) !== null && _a !== void 0 ? _a : [];
+    const properties = (_b = schema.properties) !== null && _b !== void 0 ? _b : {};
+    for (const key of Object.keys(properties)) {
+        if (requiredFields.includes(key)) {
+            properties[key].required = true;
+        }
+    }
+    return properties;
+}
+exports.jsonSchemaToFields = jsonSchemaToFields;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGRzLXRvLWpzb25zY2hlbWEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVzdGluYXRpb24ta2l0L2ZpZWxkcy10by1qc29uc2NoZW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBLFNBQWdCLGtCQUFrQixDQUFDLFNBQXFDLEVBQUU7SUFDeEUsTUFBTSxRQUFRLEdBQWEsRUFBRSxDQUFBO0lBQzdCLE1BQU0sVUFBVSxHQUFnQyxFQUFFLENBQUE7SUFFbEQsS0FBSyxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1FBQ3JDLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUV6Qix3R0FBd0c7UUFDeEcsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLEtBQUssQ0FBZ0IsQ0FBQTtRQUN6RCxPQUFPLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLENBQUE7UUFFL0IsZ0RBQWdEO1FBQ2hELElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRTtZQUNsQixRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1NBQ25CO0tBQ0Y7SUFFRCxPQUFPO1FBQ0wsT0FBTyxFQUFFLGdDQUFnQztRQUN6QyxJQUFJLEVBQUUsUUFBUTtRQUNkLG9CQUFvQixFQUFFLEtBQUs7UUFDM0IsVUFBVTtRQUNWLFFBQVE7S0FDVCxDQUFBO0FBQ0gsQ0FBQztBQXhCRCxnREF3QkM7QUFFRCxTQUFnQixrQkFBa0IsQ0FBQyxTQUFzQixFQUFFOztJQUN6RCxNQUFNLGNBQWMsU0FBSSxNQUFNLENBQUMsUUFBcUIsbUNBQUksRUFBRSxDQUFBO0lBQzFELE1BQU0sVUFBVSxTQUFJLE1BQU0sQ0FBQyxVQUF5QyxtQ0FBSSxFQUFFLENBQUE7SUFFMUUsS0FBSyxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFO1FBQ3pDLElBQUksY0FBYyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRTtZQUNoQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQTtTQUNoQztLQUNGO0lBRUQsT0FBTyxVQUFVLENBQUE7QUFDbkIsQ0FBQztBQVhELGdEQVdDIn0=

package/dist/cjs/destination-kit/index.d.ts

@@ -0,0 +1,84 @@
+import { CancelableRequest, Got, Response } from 'got';
+import { JSONSchema4 } from 'json-schema';
+import { Action, ActionDefinition } from './action';
+import { ExecuteInput, StepResult } from './step';
+import { JSONLikeObject, JSONObject } from '../json-object';
+import { SegmentEvent } from '../segment-event';
+import { fieldsToJsonSchema, jsonSchemaToFields } from './fields-to-jsonschema';
+import type { InputField, RequestExtension } from './types';
+export type { ActionDefinition, ExecuteInput };
+export { fieldsToJsonSchema, jsonSchemaToFields };
+export interface SubscriptionStats {
+    duration: number;
+    destination: string;
+    action: string;
+    subscribe: string;
+    state: string;
+    input: JSONLikeObject;
+    output: StepResult[] | null;
+}
+interface PartnerActions<Settings, Payload extends JSONLikeObject> {
+    [key: string]: Action<Settings, Payload>;
+}
+export interface DestinationDefinition<Settings = unknown> {
+    /** The name of the destination */
+    name: string;
+    /** An optional function to extend requests sent from the destination (including all actions) */
+    extendRequest?: RequestExtension<Settings>;
+    /** Optional authentication configuration */
+    authentication?: AuthenticationScheme<Settings>;
+    /** Actions */
+    actions: {
+        [key: string]: ActionDefinition<Settings>;
+    };
+    /** Subscription presets automatically applied in quick setup */
+    presets?: Subscription[];
+}
+export interface Subscription {
+    name?: string;
+    partnerAction: string;
+    subscribe: string;
+    mapping?: JSONObject;
+}
+interface TestAuthSettings<Settings> {
+    settings: Settings;
+}
+interface Authentication<Settings> {
+    scheme: 'basic' | 'custom';
+    fields: Record<string, InputField>;
+    testAuthentication: (req: Got, input: TestAuthSettings<Settings>) => CancelableRequest<Response<string>>;
+}
+export interface CustomAuthentication<Settings> extends Authentication<Settings> {
+    /** Typically used for "API Key" authentication. */
+    scheme: 'custom';
+}
+export interface BasicAuthentication<Settings> extends Authentication<Settings> {
+    scheme: 'basic';
+}
+export declare type AuthenticationScheme<Settings = any> = BasicAuthentication<Settings> | CustomAuthentication<Settings>;
+interface EventInput<Settings> {
+    readonly event: SegmentEvent;
+    readonly mapping: JSONObject;
+    readonly settings: Settings;
+}
+export declare class Destination<Settings = JSONObject> {
+    readonly definition: DestinationDefinition<Settings>;
+    readonly name: string;
+    readonly authentication?: AuthenticationScheme<Settings>;
+    readonly extendRequest?: RequestExtension<Settings>;
+    readonly actions: PartnerActions<Settings, any>;
+    readonly responses: Response[];
+    readonly settingsSchema?: JSONSchema4;
+    constructor(destination: DestinationDefinition<Settings>);
+    testAuthentication(settings: Settings): Promise<void>;
+    private partnerAction;
+    protected executeAction(actionSlug: string, { event, mapping, settings }: EventInput<Settings>): Promise<StepResult[]>;
+    private onSubscription;
+    /**
+     * Note: Until we move subscriptions upstream (into int-consumer) we've opted
+     * to have failures abort the set of subscriptions and get potentially retried by centrifuge
+     */
+    onEvent(event: SegmentEvent, settings: JSONObject, onComplete?: (stats: SubscriptionStats) => void): Promise<StepResult[]>;
+    private getSubscriptions;
+    private getDestinationSettings;
+}