@membranehq/sdk 0.1.0

package/dist/dts/data-sources/accessors.d.ts

@@ -0,0 +1,64 @@
+import { ElementAccessor, ElementInstanceAccessor, ElementInstanceListAccessor, ElementListAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { DataCollectionCreateRequest, DataCollectionCreateResponse, DataCollectionDeleteResponse, DataCollectionFindByIdRequest, DataCollectionFindByIdResponse, DataCollectionFindRequest, DataCollectionFindResponse, DataCollectionListRequest, DataCollectionListResponse, DataCollectionMatchRequest, DataCollectionMatchResponse, DataCollectionSearchRequest, DataCollectionSearchResponse, DataCollectionSpec, DataCollectionUpdateRequest, DataCollectionUpdateResponse } from '../connectors/data-locations';
+import { OpenConfigurationOptions } from '../iframe';
+import { CreateDataSourceInstanceRequest, CreateDataSourceRequest, DataSourceInstanceSelector, FindDataSourceInstancesQuery, FindDataSourcesQuery, ListDataSourceInstancesForConnectionQuery, ListDataSourcesForIntegrationQuery, UpdateDataSourceInstanceRequest, UpdateDataSourceRequest } from './api';
+import { InstanceKeyQuery } from '../integration-elements/common';
+import { ConnectionLevelElementAccessor, ConnectionLevelElementsListAccessor } from '../integration-elements/connection-level-element.accessor';
+import { IntegrationLevelElementAccessor, IntegrationLevelElementsListAccessor } from '../integration-elements/integration-level-element.accessor';
+import { DataSource, DataSourceInstance, DataSourceSelector } from '.';
+export interface OpenDataSourceConfigurationOptions extends OpenConfigurationOptions {
+}
+export declare class DataSourcesAccessor extends ElementListAccessor<DataSource, FindDataSourcesQuery, CreateDataSourceRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class DataSourceAccessor extends ElementAccessor<DataSource, UpdateDataSourceRequest, DataSourceSelector> {
+    constructor(client: IntegrationAppApiClient, selector: DataSourceSelector | string);
+    apply(integrationKeys: string[]): Promise<DataSource[]>;
+    setup(): Promise<void>;
+    reset(): Promise<any>;
+}
+export declare class DataSourceInstancesAccessor extends ElementInstanceListAccessor<DataSourceInstance, FindDataSourceInstancesQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class DataSourceInstanceAccessor extends ElementInstanceAccessor<DataSourceInstance, DataSourceInstanceSelector, CreateDataSourceInstanceRequest, UpdateDataSourceInstanceRequest> {
+    client: IntegrationAppApiClient;
+    constructor(client: IntegrationAppApiClient, selector: string | DataSourceInstanceSelector);
+    setup(): Promise<void>;
+    reset(): Promise<void>;
+    openConfiguration({ onClose }?: OpenDataSourceConfigurationOptions): Promise<void>;
+    unifiedFieldsToNative(unifiedFields: any): Promise<any>;
+    getCollection(): Promise<DataCollectionSpec>;
+    listRecords(request?: DataCollectionListRequest): Promise<DataCollectionListResponse>;
+    matchRecord(request: DataCollectionMatchRequest): Promise<DataCollectionMatchResponse>;
+    searchRecords(request: DataCollectionSearchRequest): Promise<DataCollectionSearchResponse>;
+    findRecordById(request: string | DataCollectionFindByIdRequest): Promise<DataCollectionFindByIdResponse>;
+    createRecord(request: DataCollectionCreateRequest): Promise<DataCollectionCreateResponse>;
+    updateRecord(request: DataCollectionUpdateRequest): Promise<DataCollectionUpdateResponse>;
+    deleteRecord(request: string | DataCollectionFindByIdRequest): Promise<DataCollectionDeleteResponse>;
+    findRecords(request?: DataCollectionFindRequest): Promise<DataCollectionFindResponse>;
+}
+export declare class IntegrationLevelDataSourceAccessor extends IntegrationLevelElementAccessor<DataSource, UpdateDataSourceRequest> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    dataSourceSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, dataSourceSelector: string);
+}
+export declare class IntegrationLevelDataSourcesListAccessor extends IntegrationLevelElementsListAccessor<DataSource, ListDataSourcesForIntegrationQuery, Omit<CreateDataSourceRequest, 'integrationId'>> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+}
+export declare class ConnectionLevelDataSourceAccessor extends ConnectionLevelElementAccessor<DataSourceInstance, UpdateDataSourceInstanceRequest> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    dataSourceSelector: string;
+    query: InstanceKeyQuery;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, dataSourceSelector: string, query: InstanceKeyQuery);
+    openConfiguration(options?: OpenDataSourceConfigurationOptions): Promise<void>;
+}
+export declare class ConnectionLevelDataSourcesAccessor extends ConnectionLevelElementsListAccessor<DataSource, ListDataSourceInstancesForConnectionQuery> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+}

package/dist/dts/data-sources/api.d.ts

@@ -0,0 +1,90 @@
+import { ElementInstanceSelector } from '../accessors';
+import { ConnectionSelector } from '../connections';
+import { PaginationQuery, PaginationResponse } from '../entity-repository';
+import { FlowInstanceSelector } from '../flows';
+import { DataSourceInstance } from '.';
+export interface ListDataSourcesForIntegrationQuery extends PaginationQuery {
+    universalDataSourceId?: string | 'null';
+}
+export interface FindDataSourcesQuery extends ListDataSourcesForIntegrationQuery {
+    integrationId?: string | 'null';
+}
+export type CreateDataSourceRequest = {
+    key: string;
+    name: string;
+    integrationId?: string;
+    udm?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    rootPath?: string;
+    defaultPath?: string;
+    collectionKey?: string;
+    collectionParameters?: any;
+};
+export type UpdateDataSourceRequest = {
+    key?: string;
+    name?: string;
+    archivedAt?: string;
+    udm?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    rootPath?: string;
+    defaultPath?: string;
+};
+export interface DataSourceInstanceSelector extends ConnectionSelector, FlowInstanceSelector, ElementInstanceSelector {
+    dataSourceKey?: string;
+    dataSourceId?: string;
+    instanceKey?: string;
+    nodeKey?: string;
+    udm?: string;
+}
+export interface FindDataSourceInstancesQuery extends PaginationQuery {
+    userId?: string;
+    dataSourceId?: string;
+    universalDataSourceId?: string;
+    connectionId?: string;
+    integrationKey?: string;
+    integrationId?: string;
+}
+export type FindDataSourceInstancesResponse = PaginationResponse<DataSourceInstance>;
+export interface CreateDataSourceInstanceRequest {
+    dataSourceId: string;
+    connectionId: string;
+    path?: string;
+}
+export interface UpdateDataSourceInstanceRequest {
+    path?: string;
+    collectionKey?: string;
+    collectionParameters?: any;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    subscribedTo?: {
+        created?: boolean;
+        updated?: boolean;
+        deleted?: boolean;
+    };
+}
+export interface FindDataSourceEventsQuery extends PaginationQuery {
+    userId?: string;
+    udm?: string;
+    dataSourceInstanceId?: string;
+    startDatetime?: string;
+    endDatetime?: string;
+}
+export interface FindDataSourceSyncsQuery extends PaginationQuery {
+    userId?: string;
+    dataSourceId?: string;
+    dataSourceInstanceId?: string;
+    integrationId?: string;
+    connectionId?: string;
+    startedAfter?: string;
+}
+export type ListDataSourceInstancesForConnectionQuery = PaginationQuery & {
+    dataSourceId?: string;
+};
+export interface FindDataSourceInstanceSyncsQuery extends ListDataSourceInstancesForConnectionQuery {
+    userId?: string;
+    connectionId?: string;
+    integrationId?: string;
+    dataSourceInstanceId?: string;
+}

package/dist/dts/data-sources/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_PULL_UPDATES_INTERVAL_SECONDS: number;
+export declare const DEFAULT_FULL_SYNC_INTERVAL_SECONDS: number;
+export declare const MIN_FULL_SYNC_INTERVAL_SECONDS: number;
+export declare const MIN_PULL_UPDATES_INTERVAL_SECONDS: number;

package/dist/dts/data-sources/index.d.ts

@@ -0,0 +1,4 @@
+export * from './accessors';
+export * from './api';
+export * from './constants';
+export * from './types';

package/dist/dts/data-sources/types.d.ts

@@ -0,0 +1,63 @@
+import { IntegrationSpecificElementSelector } from '../accessors';
+import { Connection } from '../connections';
+import { DataCollectionSpec } from '../connectors';
+import { ErrorData } from '../errors';
+import { AppliedToIntegrations, Integration } from '../integrations';
+import { User } from '../users';
+import { WorkspaceElement } from '../workspace-elements';
+export interface DataSourceUnitConfig {
+    key?: string;
+    collectionKey?: any;
+    collectionParameters?: any;
+    udm?: any;
+    path?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+}
+export interface DataSource extends WorkspaceElement {
+    revision: string;
+    publishedRevision?: string;
+    integrationId?: string;
+    integration?: Integration;
+    universalDataSourceId?: string;
+    universalDataSourceRevision?: string;
+    udm?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    collectionKey?: string;
+    collectionParameters?: any;
+    archivedAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    customized?: boolean;
+    appliedToIntegrations?: AppliedToIntegrations<DataSource>;
+    defaultPath?: string;
+}
+export interface DataSourceInstance extends WorkspaceElement {
+    userId: string;
+    revision: string;
+    user?: User;
+    dataSourceRevision?: string;
+    dataSourceId?: string;
+    universalDataSourceId?: string;
+    dataSource?: DataSource;
+    udm?: string;
+    connectionId: string;
+    connection?: Connection;
+    integrationId: string;
+    integration?: Integration;
+    instanceKey?: string;
+    collectionKey?: string;
+    collectionParameters?: any;
+    defaultCollectionKey?: string;
+    defaultCollectionParameters?: any;
+    collectionSpec?: DataCollectionSpec;
+    isCustomized?: boolean;
+    errors?: ErrorData[];
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    path?: string;
+    defaultPath?: string;
+}
+export interface DataSourceSelector extends IntegrationSpecificElementSelector {
+}

package/dist/dts/date-time/index.d.ts

@@ -0,0 +1 @@
+export * from './parse';

package/dist/dts/date-time/parse.d.ts

@@ -0,0 +1 @@
+export declare function parseDate(value: any): Date | undefined;

package/dist/dts/date-time/parse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/datetime.d.ts

@@ -0,0 +1 @@
+export declare function parseDatetime(str: string): Date;

package/dist/dts/entity-repository.d.ts

@@ -0,0 +1,24 @@
+export type CommonListElementsQuery = SearchQuery & PaginationQuery & IncludeArchivedQuery;
+export type CommonInstancesListQuery = CommonListElementsQuery & {
+    userId?: string;
+    instanceKey?: string;
+};
+export type CommonIntegrationOrConnectionQuery = {
+    connectionId?: string;
+    integrationId?: string;
+    integrationKey?: string;
+};
+export type IncludeArchivedQuery = {
+    includeArchived?: boolean;
+};
+export type SearchQuery = {
+    search?: string;
+};
+export type PaginationQuery = {
+    limit?: number;
+    cursor?: string;
+};
+export declare class PaginationResponse<T> {
+    items: T[];
+    cursor?: string;
+}

package/dist/dts/errors/error-doc-enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum ErrorDoc {
+    AuthenticationTokenErrors = "authentication-token-errors",
+    DataSourceNoCollectionSelected = "data-source-no-collection-selected",
+    FlowInstanceSetupFailed = "flow-instance-setup-failed",
+    FlowInstanceSetupTimeout = "flow-instance-setup-timeout",
+    WebhookCannotFindUser = "webhook-cannot-find-user"
+}

package/dist/dts/errors/index.d.ts

@@ -0,0 +1,105 @@
+import { WorkspaceElementReference } from '../workspace-elements';
+import { ErrorDoc } from './error-doc-enum';
+export * from './error-doc-enum';
+export declare enum ErrorType {
+    BAD_REQUEST = "bad_request",
+    CONNECTION = "connection",
+    CONFIGURATION = "configuration",
+    DEPENDENCY_ERROR = "dependency_error",
+    FLOW_RUN = "flow_run",
+    FLOW_INSTANCE_SETUP = "flow_instance_setup",
+    CONCURRENCY = "concurrency",
+    INTERNAL = "internal",
+    ACTION_RUN = "action_run",
+    ACTION_INSTANCE_SETUP = "action_instance_setup",
+    UNIT_RUN = "unit_run",
+    CUSTOM_CODE = "custom_code"
+}
+export declare enum BadRequestErrorKey {
+    NOT_FOUND = "not_found",
+    NOT_AUTHENTICATED = "not_authenticated",
+    ACCESS_DENIED = "access_denied",
+    ALREADY_EXISTS = "already_exists",
+    RATE_LIMIT_EXCEEDED = "rate_limit_exceeded"
+}
+export declare enum ConnectionErrorKey {
+    CONNECTION_IS_DEFUNCT = "connection_is_defunct",
+    ACCESS_TOKEN_EXPIRED = "access_token_expired",
+    RATE_LIMIT_EXCEEDED = "rate_limit_exceeded"
+}
+export declare enum ConcurrencyErrorKey {
+    LOCK_TIMEOUT = "lock_timeout"
+}
+interface ErrorDataFields {
+    type?: ErrorType;
+    key?: string;
+    message: string;
+    data?: any;
+    doc?: ErrorDoc;
+    stack?: any;
+    causedByError?: ErrorData;
+    logs?: any[];
+}
+type ErrorConstructorArg = string | ErrorDataFields | Error;
+export declare function isIntegrationAppError(error: any): any;
+export declare class ErrorData implements ErrorDataFields {
+    constructor(arg: ErrorConstructorArg);
+}
+export interface ErrorData extends ErrorDataFields {
+}
+export declare class IntegrationAppError extends Error {
+    isIntegrationAppError: true;
+    data: ErrorData;
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class InternalError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class BadRequestError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class ConcurrencyError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class ConfigurationError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class DependencyError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg, workspaceElementReference?: WorkspaceElementReference);
+}
+export declare class FlowInstanceSetupError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class FlowRunError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class ActionRunError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class ActionInstanceSetupError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class UnitRunError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class ConnectionError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class NotFoundError extends BadRequestError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class RateLimitExceededError extends BadRequestError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class NotAuthenticatedError extends BadRequestError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class AccessDeniedError extends BadRequestError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare class CustomCodeError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg);
+}
+export declare function getErrorFromData(data: any): any;
+export declare function extractIntegrationAppErrorData(error: any): ErrorData;
+export declare function buildUserFriendlyErrorMessage({ message, doc }: ErrorData): string;

package/dist/dts/external-events/accessors.d.ts

@@ -0,0 +1,19 @@
+import { ElementInstanceListAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { FindExternalEventSubscriptionsQuery } from './api';
+import { ExternalEventSubscription } from './types';
+export declare class ExternalEventSubscriptionsAccessor extends ElementInstanceListAccessor<ExternalEventSubscription, FindExternalEventSubscriptionsQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class ExternalEventSubscriptionAccessor {
+    private client;
+    private id;
+    constructor(client: IntegrationAppApiClient, id: string);
+    get(): Promise<ExternalEventSubscription>;
+    setup(): Promise<void>;
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    resubscribe(): Promise<void>;
+    pullEvents(): Promise<void>;
+    private getPath;
+}

package/dist/dts/external-events/api.d.ts

@@ -0,0 +1,22 @@
+import { PaginationQuery } from '../entity-repository';
+import { ExternalEventLogStatus } from './types';
+export interface FindExternalEventSubscriptionsQuery extends PaginationQuery {
+    userId?: string;
+    connectionId?: string;
+    integrationId?: string;
+}
+export interface FindExternalEventLogsQuery extends PaginationQuery {
+    userId?: string;
+    externalEventSubscriptionId?: string;
+    connectionId?: string;
+    integrationId?: string;
+    startDatetime?: string;
+    status?: ExternalEventLogStatus;
+}
+export interface FindExternalEventPullsQuery extends PaginationQuery {
+    userId?: string;
+    externalEventSubscriptionId?: string;
+    integrationId?: string;
+    connectionId?: string;
+    startedAfter?: string;
+}

package/dist/dts/external-events/index.d.ts

@@ -0,0 +1,8 @@
+import { DataCollectionEventType } from '../data-collections';
+import { ExternalEventSubscriptionType, ExternalEventType } from './types';
+export * from './types';
+export * from './accessors';
+export * from './api';
+export declare function externalEventTypeToDataCollectionEventType(type: ExternalEventType): DataCollectionEventType;
+export declare function dataCollectionEventTypeToExternalEventType(type: DataCollectionEventType): ExternalEventType;
+export declare function externalEventTypeToSubscriptionType(type: ExternalEventType): ExternalEventSubscriptionType;

package/dist/dts/external-events/types.d.ts

@@ -0,0 +1,157 @@
+import { Connection } from '../connections';
+import { DataSourceUnitConfig } from '../data-sources';
+import { ErrorData } from '../errors';
+import { AppliedToIntegrations, Integration } from '../integrations';
+import { Customer } from '../users';
+export declare enum ExternalEventType {
+    DataRecordCreated = "data-record-created",
+    DataRecordUpdated = "data-record-updated",
+    DataRecordDeleted = "data-record-deleted",
+    ConnectorEvent = "connector-event"
+}
+export declare enum ExternalEventSubscriptionStatus {
+    Subscribed = "subscribed",
+    Unsubscribed = "unsubscribed",
+    Error = "error"
+}
+export declare enum ExternalEventPullStatus {
+    RUNNING = "running",
+    SUCCESS = "success",
+    ERROR = "error",
+    QUEUED = "queued"
+}
+export declare enum IncomingWebhooksState {
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface ExternalEventUnitConfig {
+    type: ExternalEventType;
+    dataSource?: DataSourceUnitConfig;
+    eventKey?: string;
+    eventParameters?: any;
+}
+export declare enum ExternalEventSubscriptionType {
+    DataRecordCreated = "data-record-created",
+    DataRecordUpdated = "data-record-updated",
+    DataRecordDeleted = "data-record-deleted",
+    ConnectorEvent = "connector-event"
+}
+export interface ExternalEventSubscriptionConfig {
+    type: ExternalEventSubscriptionType;
+    dataSource?: DataSourceUnitConfig;
+    eventKey?: string;
+    eventParameters?: any;
+}
+export interface ExternalEvent {
+    config?: ExternalEventUnitConfig;
+    appliedToIntegrations?: AppliedToIntegrations<ExternalEvent>;
+}
+export interface ExternalEventSubscription {
+    id: string;
+    name?: string;
+    userId: string;
+    user?: Customer;
+    connectionId: string;
+    connection?: Connection;
+    integrationId: string;
+    integration?: Integration;
+    uuid: string;
+    config?: ExternalEventSubscriptionConfig;
+    status?: ExternalEventSubscriptionStatus;
+    error?: ErrorData;
+    isRealTime?: boolean;
+    requiresPull?: boolean;
+    requiresFullSync?: boolean;
+    createdAt?: string;
+    archivedAt?: string;
+    stateData?: any;
+    nextPullEventsTimestamp?: number;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    nextRefreshTimestamp?: number;
+    globalWebhookKey?: string;
+    globalWebhookEventSelector?: string;
+}
+export declare enum ExternalEventLogStatus {
+    CREATED = "created",
+    ERROR = "error",
+    SUCCESS = "success"
+}
+export interface ExternalEventLogRecord {
+    id: string;
+    userId: string;
+    user?: Customer;
+    name?: string;
+    externalEventSubscriptionId: string;
+    externalEventSubscription?: ExternalEventSubscription;
+    integrationId: string;
+    integration?: Integration;
+    connectionId: string;
+    connection?: Connection;
+    payload?: any;
+    launchedFlowRunIds?: string[];
+    status: ExternalEventLogStatus;
+    error?: ErrorData;
+}
+export interface ExternalEventCustomPullSubscribeResponse {
+    state: Record<string, any>;
+}
+export interface ExternalEventCustomPullCollectEventsRequest {
+    state: Record<string, any>;
+}
+export interface ExternalEventCustomPullCollectEventsResponse<EventPayload = any> {
+    events: EventPayload[];
+    state: Record<string, any>;
+}
+export interface ExternalEventWebhookSubscribeRequest {
+    webhookUri: string;
+}
+export interface ExternalEventWebhookSubscribeResponse {
+    state?: Record<string, any>;
+    nextRefreshTimestamp?: number;
+}
+export interface ExternalEventWebhookUnsubscribeRequest {
+    state: Record<string, any>;
+}
+export interface ExternalEventWebhookHandleRequest {
+    state: Record<string, any>;
+    query: Record<string, string>;
+    data: any;
+    rawBody?: string;
+    headers: any;
+}
+export interface ExternalEventWebhookHandleResponse<EventPayload = any> {
+    events?: EventPayload[];
+    response?: {
+        headers?: Record<string, string>;
+        data?: any;
+        status?: number;
+    };
+    state?: Record<string, any>;
+}
+export interface ExternalEventWebhookRefreshRequest {
+    state: Record<string, any>;
+    webhookUri: string;
+}
+export interface ExternalEventWebhookRefreshResponse {
+    state?: Record<string, any>;
+    nextRefreshTimestamp?: number;
+}
+export interface ExternalEventPull {
+    id: string;
+    name?: string;
+    userId: string;
+    user?: Customer;
+    externalEventSubscriptionId: string;
+    externalEventSubscription?: ExternalEventSubscription;
+    integrationId: string;
+    integration?: Integration;
+    connectionId: string;
+    connection?: Connection;
+    startDatetime: string;
+    endDatetime: string;
+    isFullScan?: boolean;
+    status: ExternalEventPullStatus;
+    collectedEventIds: string[];
+    error?: ErrorData;
+}

package/dist/dts/field-mappings/accessors.d.ts

@@ -0,0 +1,54 @@
+import { ElementAccessor, ElementInstanceAccessor, ElementInstanceListAccessor, ElementListAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { OpenConfigurationOptions } from '../iframe';
+import { CreateFieldMappingInstanceRequest, CreateFieldMappingRequest, FieldMappingInstanceSelector, FindFieldMappingInstancesQuery, FindFieldMappingsQuery, ListFieldMappingInstancesForConnectionQuery, ListFieldMappingsForIntegrationQuery, UpdateFieldMappingInstanceRequest, UpdateFieldMappingRequest } from './api';
+import { InstanceKeyQuery } from '../integration-elements/common';
+import { ConnectionLevelElementAccessor, ConnectionLevelElementsListAccessor } from '../integration-elements/connection-level-element.accessor';
+import { IntegrationLevelElementAccessor, IntegrationLevelElementsListAccessor } from '../integration-elements/integration-level-element.accessor';
+import { FieldMapping, FieldMappingInstance, FieldMappingSelector } from '.';
+export interface OpenFieldMappingInstanceConfigurationOptions extends OpenConfigurationOptions {
+}
+export declare class FieldMappingsAccessor extends ElementListAccessor<FieldMapping, FindFieldMappingsQuery, CreateFieldMappingRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class FieldMappingAccessor extends ElementAccessor<FieldMapping, UpdateFieldMappingRequest, FieldMappingSelector> {
+    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingSelector);
+    getAppSchema(): Promise<any>;
+    apply(integrationKeys: string[]): Promise<FieldMapping[]>;
+    setup(): Promise<any>;
+    reset(): Promise<any>;
+}
+export declare class FieldMappingInstancesAccessor extends ElementInstanceListAccessor<FieldMappingInstance, FindFieldMappingInstancesQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class FieldMappingInstanceAccessor extends ElementInstanceAccessor<FieldMappingInstance, FieldMappingInstanceSelector, CreateFieldMappingInstanceRequest, UpdateFieldMappingInstanceRequest> {
+    private client;
+    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingInstanceSelector);
+    setup(): Promise<void>;
+    reset(): Promise<void>;
+    openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
+}
+export declare class IntegrationLevelFieldMappingAccessor extends IntegrationLevelElementAccessor<FieldMapping, UpdateFieldMappingRequest> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    fieldMappingSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, fieldMappingSelector: string);
+}
+export declare class IntegrationLevelFieldMappingsListAccessor extends IntegrationLevelElementsListAccessor<FieldMapping, ListFieldMappingsForIntegrationQuery, Omit<CreateFieldMappingRequest, 'integrationId'>> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+}
+export declare class ConnectionLevelFieldMappingAccessor extends ConnectionLevelElementAccessor<FieldMappingInstance, UpdateFieldMappingInstanceRequest> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    fieldMappingSelector: string;
+    query: InstanceKeyQuery;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, fieldMappingSelector: string, query: InstanceKeyQuery);
+    openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
+}
+export declare class ConnectionLevelFieldMappingsAccessor extends ConnectionLevelElementsListAccessor<FieldMapping, ListFieldMappingInstancesForConnectionQuery> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+}