@membranehq/sdk 0.1.0

package/dist/dts/__mocks__/axios.d.ts

@@ -0,0 +1,4 @@
+export const axiosMock: MockAdapter;
+export default axios;
+import MockAdapter from 'axios-mock-adapter';
+import axios from 'axios';

package/dist/dts/_helper.d.ts

@@ -0,0 +1,7 @@
+type StructuredCloneType = <T>(value: T) => T;
+export declare const structuredClone: StructuredCloneType;
+export declare function isNil(value?: any): boolean;
+export declare function omitBy(obj: Record<string, any>, check: (value: any) => boolean): Record<string, any>;
+export declare function isEmptyValue(value?: any): boolean;
+export declare const simpleUniqueId: () => string;
+export {};

package/dist/dts/_helper.test.d.ts

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

package/dist/dts/accessors.d.ts

@@ -0,0 +1,85 @@
+import { IntegrationAppApiClient } from './api-client';
+import { PaginationResponse } from './entity-repository';
+import { WorkspaceElementType } from './workspace-elements';
+export interface BaseElementInstance {
+    id: string;
+}
+export interface ElementInstanceSelector {
+    id?: string;
+    autoCreate?: boolean;
+    instanceKey?: string;
+    userId?: string;
+    parentKey?: string;
+    parentId?: string;
+}
+export interface IntegrationSpecificElementSelector {
+    id?: string;
+    key?: string;
+    integrationId?: string;
+    integrationKey?: string;
+}
+type SelectorType = {
+    id?: string;
+} | string;
+export declare class ElementAccessor<Element, UpdateRequest, Selector extends SelectorType = string> {
+    protected options: {
+        client: IntegrationAppApiClient;
+        path: string;
+        selector: string | Selector;
+    };
+    constructor(options: {
+        client: IntegrationAppApiClient;
+        path: string;
+        selector: string | Selector;
+    });
+    getUniqueIdentifier(): string;
+    get(): Promise<Element>;
+    put(data: UpdateRequest): Promise<Element>;
+    patch(data: Partial<UpdateRequest>): Promise<Element>;
+    archive(): Promise<void>;
+    restore(): Promise<Element>;
+    getPath(operation?: string): string;
+}
+export declare class ElementListAccessor<Element, FindQuery, CreateRequest> {
+    private client;
+    private path;
+    constructor(client: IntegrationAppApiClient, path: string);
+    find(query?: FindQuery): Promise<PaginationResponse<Element>>;
+    findAll(query?: Omit<FindQuery, 'limit'>): Promise<Element[]>;
+    create(data: CreateRequest): Promise<Element>;
+}
+export declare class ElementInstanceListAccessor<ElementInstance extends BaseElementInstance, FindQuery> {
+    protected client: IntegrationAppApiClient;
+    private path;
+    constructor(client: IntegrationAppApiClient, path: string);
+    find(query?: FindQuery): Promise<PaginationResponse<ElementInstance>>;
+}
+export declare class ElementInstanceAccessor<ElementInstance extends BaseElementInstance, Selector extends {
+    id?: string;
+}, CreateRequest, UpdateRequest> {
+    protected options: {
+        client: IntegrationAppApiClient;
+        instancePath: string;
+        selector: string | Selector;
+        type?: WorkspaceElementType;
+    };
+    private id;
+    constructor(options: {
+        client: IntegrationAppApiClient;
+        instancePath: string;
+        selector: string | Selector;
+        type?: WorkspaceElementType;
+    });
+    getUniqueIdentifier(): string;
+    get(): Promise<ElementInstance>;
+    getId(): Promise<string>;
+    create(data?: CreateRequest): Promise<ElementInstance>;
+    put(data: CreateRequest): Promise<ElementInstance>;
+    patch(data: UpdateRequest): Promise<ElementInstance>;
+    archive(): Promise<void>;
+    delete(): Promise<void>;
+    restore(): Promise<ElementInstance>;
+    protected getPath(operation?: string): string;
+    private getSelector;
+}
+export {};

package/dist/dts/accessors.test.d.ts

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

package/dist/dts/actions/accessors.d.ts

@@ -0,0 +1,49 @@
+import { ElementAccessor, ElementInstanceAccessor, ElementInstanceListAccessor, ElementListAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { Action, ActionInstance, ActionInstanceSelector, ActionRunResponse, ActionSelector, CreateActionInstanceRequest, CreateActionRequest, FindActionInstancesQuery, FindActionsQuery, ListActionInstancesForConnectionQuery, ListActionsForIntegrationQuery, OpenActionConfigurationOptions, UpdateActionInstanceRequest, UpdateActionRequest } from './types';
+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';
+export declare class ActionsAccessor extends ElementListAccessor<Action, FindActionsQuery, CreateActionRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class ActionAccessor extends ElementAccessor<Action, UpdateActionRequest, ActionSelector> {
+    constructor(client: IntegrationAppApiClient, selector: ActionSelector | string);
+    apply(integrationKeys: string[]): Promise<Action[]>;
+    reset(): Promise<any>;
+}
+export declare class ActionInstancesAccessor extends ElementInstanceListAccessor<ActionInstance, FindActionInstancesQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class ActionInstanceAccessor extends ElementInstanceAccessor<ActionInstance, ActionInstanceSelector, CreateActionInstanceRequest, UpdateActionInstanceRequest> {
+    client: IntegrationAppApiClient;
+    constructor(client: IntegrationAppApiClient, selector: string | ActionInstanceSelector);
+    setup(): Promise<void>;
+    reset(): Promise<void>;
+    run(input?: any): Promise<ActionRunResponse>;
+    open({ onClose }?: OpenActionConfigurationOptions): Promise<void>;
+}
+export declare class IntegrationLevelActionAccessor extends IntegrationLevelElementAccessor<Action, UpdateActionRequest> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    actionSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, actionSelector: string);
+}
+export declare class IntegrationLevelActionsListAccessor extends IntegrationLevelElementsListAccessor<Action, ListActionsForIntegrationQuery, Omit<CreateActionRequest, 'integrationId'>> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+}
+export declare class ConnectionLevelActionAccessor extends ConnectionLevelElementAccessor<ActionInstance, UpdateActionInstanceRequest> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    actionSelector: string;
+    query: InstanceKeyQuery;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, actionSelector: string, query: InstanceKeyQuery);
+    run(input?: any): Promise<ActionRunResponse>;
+}
+export declare class ConnectionLevelActionsAccessor extends ConnectionLevelElementsListAccessor<Action, ListActionInstancesForConnectionQuery> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+}

package/dist/dts/actions/action-types.d.ts

@@ -0,0 +1,26 @@
+import { FieldMappingDirection } from '../field-mappings';
+export declare enum ActionType {
+    ListDataRecords = "list-data-records",
+    FindDataRecordById = "find-data-record-by-id",
+    MatchDataRecord = "match-data-record",
+    CreateDataRecord = "create-data-record",
+    FindOrCreateDataRecord = "find-or-create-data-record",
+    UpdateDataRecord = "update-data-record",
+    DeleteDataRecord = "delete-data-record",
+    SearchDataRecords = "search-data-record",
+    ConnectorOperation = "connector-operation",
+    ApiRequestToExternalApp = "api-request-to-external-app",
+    ApiRequestToYourApp = "api-request-to-your-app",
+    HttpRequest = "http-request",
+    RunJavascript = "run-javascript",
+    ApiRequest = "api-request"
+}
+export interface ActionSpec {
+    name: string;
+    description: string;
+    direction?: FieldMappingDirection;
+    isDataAction?: boolean;
+    isDeprecated?: boolean;
+}
+export declare function isDataActionType(type: string | ActionType): any;
+export declare const ACTIONS: Record<ActionType, ActionSpec>;

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

@@ -0,0 +1,3 @@
+export * from './accessors';
+export * from './action-types';
+export * from './types';

package/dist/dts/actions/types.d.ts

@@ -0,0 +1,95 @@
+import { ElementInstanceSelector, IntegrationSpecificElementSelector } from '../accessors';
+import { ConnectionSelector } from '../connections';
+import { DataSchema } from '../data-schema';
+import { PaginationQuery } from '../entity-repository';
+import { OpenConfigurationOptions } from '../iframe';
+import { ElementInstanceFields, ElementTemplateFields } from '../integration-elements';
+import { AppliedToIntegrations } from '../integrations';
+import { ActionType } from './action-types';
+import { WorkspaceElementDependency, WorkspaceElementState } from '../workspace-elements';
+export declare enum ActionDependencyType {
+    FieldMapping = "FieldMapping",
+    DataSource = "DataSource"
+}
+export interface ActionDependency {
+    type: ActionDependencyType;
+    key: string;
+    element?: any;
+}
+export interface Action extends ElementTemplateFields {
+    type: ActionType;
+    inputSchema?: DataSchema;
+    config?: any;
+    outputMapping?: any;
+    customOutputSchema?: DataSchema;
+    defaultOutputSchema?: DataSchema;
+    transformedOutputSchema?: DataSchema;
+    outputSchema?: DataSchema;
+    appliedToIntegrations?: AppliedToIntegrations<Action>;
+    dependencies?: WorkspaceElementDependency[];
+    isDeployed?: boolean;
+}
+export interface ActionInstance extends ElementInstanceFields {
+    type: ActionType;
+    parent?: Action;
+    instanceKey?: string;
+    inputSchema?: any;
+    config?: any;
+    outputSchema?: any;
+    isOutdated?: boolean;
+    state: WorkspaceElementState;
+}
+export interface ListActionsForIntegrationQuery extends PaginationQuery {
+    parentId?: string | 'null';
+}
+export interface FindActionsQuery extends ListActionsForIntegrationQuery {
+    integrationId?: string | 'null';
+}
+export type CreateActionRequest = {
+    key: string;
+    name: string;
+    type?: ActionType;
+    inputSchema?: any;
+    config?: any;
+    integrationId?: string;
+};
+export type UpdateActionRequest = {
+    key?: string;
+    type?: ActionType;
+    name?: string;
+    inputSchema?: any;
+    config?: any;
+    archivedAt?: string;
+};
+export interface ActionSelector extends IntegrationSpecificElementSelector {
+}
+export interface ActionInstanceSelector extends ConnectionSelector, ElementInstanceSelector {
+}
+export type ListActionInstancesForConnectionQuery = PaginationQuery & {
+    parentId?: string;
+    universalParentId?: string;
+};
+export interface FindActionInstancesQuery extends ListActionInstancesForConnectionQuery {
+    integrationKey?: string;
+    integrationId?: string;
+    userId?: string;
+    connectionId?: string;
+}
+export interface CreateActionInstanceRequest {
+    parentId: string;
+    connectionId: string;
+    config?: any;
+}
+export interface UpdateActionInstanceRequest {
+    config?: any;
+}
+export interface OpenActionConfigurationOptions extends OpenConfigurationOptions {
+}
+export interface ActionRunResponse {
+    output?: any;
+    logs?: any[];
+}
+export declare enum ActionRunLogStatus {
+    SUCCESS = "success",
+    ERROR = "error"
+}

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

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

package/dist/dts/alerts/types.d.ts

@@ -0,0 +1,24 @@
+export declare enum AlertStatus {
+    ONGOING = "ongoing",
+    RESOLVED = "resolved"
+}
+export declare enum AlertSeverity {
+    CRITICAL = "critical",
+    WARNING = "warning"
+}
+export declare enum AlertType {
+    externalEventsPerCustomerPerDay = "externalEventsPerCustomerPerDay"
+}
+export interface Alert {
+    id: string;
+    description: string;
+    status: AlertStatus;
+    type: AlertType;
+    workspaceId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    lastSeenAt: Date;
+    resolvedAt?: Date;
+    customerId?: string;
+    severity: AlertSeverity;
+}

package/dist/dts/api-client.d.ts

@@ -0,0 +1,32 @@
+import { AxiosRequestConfig } from 'axios';
+export declare const axios: import("axios").AxiosInstance;
+export declare const DEFAULT_API_URI = "https://api.integration.app";
+export declare const DEFAULT_UI_URI = "https://ui.integration.app";
+export interface IntegrationAppClientOptions {
+    token?: string;
+    fetchToken?: () => Promise<string>;
+    credentials?: any;
+    fetchCredentials?: () => Promise<any>;
+    apiUri?: string;
+    uiUri?: string;
+    accessToken?: string;
+}
+export declare class IntegrationAppApiClient {
+    apiUri: string;
+    uiUri: string;
+    token?: string;
+    protected fetchToken?: () => Promise<string>;
+    constructor({ uiUri, apiUri, accessToken, token, fetchToken, fetchCredentials, credentials, }?: IntegrationAppClientOptions);
+    setCredentials(credentials: any): Promise<any>;
+    getToken(): Promise<string>;
+    get(uri: string, queryParams?: Record<string, any>, options?: AxiosRequestConfig): Promise<any>;
+    post(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
+    put(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
+    patch(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
+    delete(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
+    getEmbedUri(page: string, pageParams?: Record<string, any>, options?: {
+        embedMode: 'isolated-embed' | 'popup-embed';
+    }): Promise<string>;
+    private makeApiRequest;
+    private handleRequestError;
+}

package/dist/dts/api-client.test.d.ts

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

package/dist/dts/app-data-schemas/accessors.d.ts

@@ -0,0 +1,18 @@
+import { ElementAccessor, ElementInstanceAccessor, ElementInstanceListAccessor, ElementListAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { AppDataSchemaInstanceSelector, CreateAppDataSchemaRequest, FindAppDataSchemaInstancesQuery, FindAppDataSchemasQuery, UpdateAppDataSchemaRequest } from './api';
+import { AppDataSchema, AppDataSchemaInstance, CreateAppDataSchemaInstanceRequest, UpdateAppDataSchemaInstanceRequest } from '.';
+export declare class AppDataSchemasAccessor extends ElementListAccessor<AppDataSchema, FindAppDataSchemasQuery, CreateAppDataSchemaRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class AppDataSchemaAccessor extends ElementAccessor<AppDataSchema, UpdateAppDataSchemaRequest> {
+    constructor(client: IntegrationAppApiClient, idOrKey: string);
+}
+export declare class AppDataSchemaInstancesAccessor extends ElementInstanceListAccessor<AppDataSchemaInstance, FindAppDataSchemaInstancesQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class AppDataSchemaInstanceAccessor extends ElementInstanceAccessor<AppDataSchemaInstance, AppDataSchemaInstanceSelector, UpdateAppDataSchemaInstanceRequest, CreateAppDataSchemaInstanceRequest> {
+    private client;
+    constructor(client: IntegrationAppApiClient, selector: string | AppDataSchemaInstanceSelector);
+    setup(): Promise<void>;
+}

package/dist/dts/app-data-schemas/api.d.ts

@@ -0,0 +1,33 @@
+import { PaginationQuery } from '../entity-repository';
+export type CreateAppDataSchemaRequest = {
+    key: string;
+    name: string;
+    schema?: any;
+    code?: string;
+};
+export type UpdateAppDataSchemaRequest = {
+    key?: string;
+    name?: string;
+    schema?: any;
+    code?: string;
+    archivedAt?: string;
+};
+export interface FindAppDataSchemasQuery extends PaginationQuery {
+}
+export interface AppDataSchemaInstanceSelector {
+    id?: string;
+    appDataSchemaKey?: string;
+    appDataSchemaId?: string;
+    instanceKey?: string;
+    autoCreate?: boolean;
+}
+export interface UpdateAppDataSchemaInstanceRequest {
+}
+export interface CreateAppDataSchemaInstanceRequest {
+}
+export interface FindAppDataSchemaInstancesQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    appDataSchemaId?: string;
+    instanceKey?: string;
+}

package/dist/dts/app-data-schemas/index.d.ts

@@ -0,0 +1,23 @@
+import { ErrorData } from '../errors';
+import { User } from '../users';
+import { WorkspaceElement } from '../workspace-elements';
+export * from './accessors';
+export * from './api';
+export interface AppDataSchema extends WorkspaceElement {
+    schema: any;
+    code?: string;
+    archivedAt?: string;
+    revision?: string;
+}
+export interface AppDataSchemaInstance extends WorkspaceElement {
+    appId: string;
+    userId: string;
+    user?: User;
+    appDataSchemaId: string;
+    appDataSchemaRevision: string;
+    appDataSchema?: AppDataSchema;
+    instanceKey?: string;
+    schema?: any;
+    error?: ErrorData;
+    archivedAt?: string;
+}

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

@@ -0,0 +1,20 @@
+import { ElementAccessor, ElementInstanceAccessor, ElementInstanceListAccessor, ElementListAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { AppEventSubscriptionSelector, CreateAppEventTypeRequest, FindAppEventSubscriptionsQuery, FindAppEventTypesQuery, AppEventSubscriptionUpdateRequest, UpdateAppEventTypeRequest } from './api';
+import { AppEventType, AppEventSubscription, FindAppEventsQuery, AppEvent } from '.';
+export declare class AppEventTypesAccessor extends ElementListAccessor<AppEventType, FindAppEventTypesQuery, CreateAppEventTypeRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class AppEventTypeAccessor extends ElementAccessor<AppEventType, UpdateAppEventTypeRequest> {
+    constructor(client: IntegrationAppApiClient, idOrKey: string);
+}
+export declare class AppEventSubscriptionsAccessor extends ElementInstanceListAccessor<AppEventSubscription, FindAppEventSubscriptionsQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class AppEventSubscriptionAccessor extends ElementInstanceAccessor<AppEventSubscription, AppEventSubscriptionSelector, AppEventSubscriptionUpdateRequest, AppEventSubscriptionUpdateRequest> {
+    constructor(client: IntegrationAppApiClient, selector: string | AppEventSubscriptionSelector);
+    subscribe(): Promise<void>;
+}
+export declare class AppEventsAccessor extends ElementInstanceListAccessor<AppEvent, FindAppEventsQuery> {
+    constructor(client: IntegrationAppApiClient);
+}

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

@@ -0,0 +1,44 @@
+import { ElementInstanceSelector } from '../accessors';
+import { DataSchema } from '../data-schema';
+import { PaginationQuery } from '../entity-repository';
+import { HttpRequestSpec } from '../http-requests';
+export interface UpdateAppEventTypeRequest {
+    key?: string;
+    name?: string;
+    subscribeRequest?: HttpRequestSpec;
+    example?: any;
+    schema?: DataSchema;
+    userIdFormula?: any;
+}
+export interface CreateAppEventTypeRequest extends UpdateAppEventTypeRequest {
+    key: string;
+    name: string;
+}
+export interface AppEventSubscriptionSelector extends Omit<ElementInstanceSelector, 'parentKey' | 'parentId'> {
+    appEventTypeKey?: string;
+    appEventTypeId?: string;
+    instanceKey?: string;
+}
+export interface AppEventSubscriptionCreateRequest {
+}
+export interface AppEventSubscriptionUpdateRequest {
+}
+export interface FindAppEventTypesQuery extends PaginationQuery {
+    includeArchived?: boolean;
+}
+export interface FindAppEventSubscriptionsQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    instanceKey?: string;
+    appEventTypeId?: string;
+    isSubscribed?: boolean;
+}
+export interface FindAppEventsQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    instanceKey?: string;
+    appEventTypeId?: string;
+    appEventSubscriptionId?: string;
+    startDatetime?: string;
+    endDatetime?: string;
+}

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

@@ -0,0 +1,42 @@
+import { DataSchema } from '../data-schema';
+import { HttpRequestSpec } from '../http-requests';
+import { User } from '../users';
+import { WorkspaceElement } from '../workspace-elements';
+export * from './api';
+export * from './accessors';
+export interface AppEventType extends WorkspaceElement {
+    revision: string;
+    archivedAt?: string;
+    subscribeRequest?: HttpRequestSpec;
+    example?: any;
+    schema?: DataSchema;
+    globalWebhookUri: string;
+    userIdFormula?: any;
+}
+export interface AppEventSubscription extends WorkspaceElement {
+    revision: string;
+    appEventTypeId: string;
+    appEventType?: AppEventType;
+    userId: string;
+    user?: User;
+    instanceKey?: string;
+    isSubscribed: boolean;
+    schema?: DataSchema;
+    webhookUri: string;
+    subscriptionRequest: HttpRequestSpec;
+    subscriptionResponse?: any;
+    archivedAt?: string;
+}
+export interface AppEvent {
+    id: string;
+    name?: string;
+    userId: string;
+    user?: User;
+    appEventTypeId: string;
+    appEventType?: AppEventType;
+    appEventSubscriptionId: string;
+    appEventSubscription?: AppEventSubscription;
+    event: any;
+    datetime: string;
+    launchedFlowRunIds: string[];
+}

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

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

package/dist/dts/apps/types.d.ts

@@ -0,0 +1,18 @@
+export interface App {
+    id: string;
+    apiDocsUri: string;
+    appUri: string;
+    canIntegrate: boolean;
+    categories: string[];
+    defaultConnectorId: string;
+    key: string;
+    logoUri: string;
+    name: string;
+    popularity: number;
+    uuid: string;
+    knowledgeBaseUuid?: string;
+}
+export interface AppCategory {
+    count: number;
+    category: string;
+}

package/dist/dts/auth/accessors.d.ts

@@ -0,0 +1,10 @@
+import { IntegrationAppApiClient } from '../api-client';
+import { Customer } from '../users';
+export declare class SelfAccessor {
+    private client;
+    constructor(client: IntegrationAppApiClient);
+    get(): Promise<Customer>;
+    patch(data: Partial<{
+        credentials: any;
+    }>): Promise<Customer>;
+}

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

@@ -0,0 +1,7 @@
+import { User } from '../users';
+import { Workspace } from '../workspaces';
+export * from './accessors';
+export interface Self {
+    user: User;
+    workspace: Workspace;
+}

package/dist/dts/client.d.ts

@@ -0,0 +1,70 @@
+import { ActionAccessor, ActionInstanceAccessor, ActionInstancesAccessor, ActionInstanceSelector, ActionsAccessor, ActionSelector } from './actions';
+import { IntegrationAppApiClient, IntegrationAppClientOptions } from './api-client';
+import { AppDataSchemaAccessor, AppDataSchemaInstanceAccessor, AppDataSchemaInstanceSelector, AppDataSchemaInstancesAccessor, AppDataSchemasAccessor } from './app-data-schemas';
+import { AppEventSubscriptionAccessor, AppEventSubscriptionSelector, AppEventSubscriptionsAccessor, AppEventTypeAccessor, AppEventTypesAccessor, AppEventsAccessor } from './app-events';
+import { SelfAccessor } from './auth';
+import { ConnectionAccessor, ConnectionsAccessor } from './connections';
+import { DataLinkTableAccessor, DataLinkTableInstanceAccessor, DataLinkTableInstanceSelector, DataLinkTableInstancesAccessor, DataLinkTablesAccessor } from './data-links';
+import { DataSourceAccessor, DataSourceInstanceAccessor, DataSourceInstanceSelector, DataSourceInstancesAccessor, DataSourceSelector, DataSourcesAccessor } from './data-sources';
+import { ExternalEventSubscriptionAccessor, ExternalEventSubscriptionsAccessor } from './external-events';
+import { FieldMappingAccessor, FieldMappingInstanceAccessor, FieldMappingInstanceSelector, FieldMappingInstancesAccessor, FieldMappingSelector, FieldMappingsAccessor } from './field-mappings';
+import { FlowRunAccessor, FlowRunsAccessor } from './flow-runs';
+import { FlowAccessor, FlowInstanceAccessor, FlowInstanceSelector, FlowInstancesAccessor, FlowSelector, FlowsAccessor } from './flows';
+import { OpenConfigurationOptions } from './iframe';
+import { IntegrationAccessor, IntegrationsAccessor } from './integrations';
+import { ScenarioAccessor, ScenariosAccessor } from './scenarios';
+import { ScreenSelector } from './screens';
+import { ScreenAccessor, ScreensAccessor } from './screens/accessors';
+import { CustomerAccessor, CustomersAccessor, CustomerSelector } from './users';
+interface OpenIntegrationAppConfigurationOptions extends OpenConfigurationOptions {
+}
+export declare class IntegrationAppClient extends IntegrationAppApiClient {
+    constructor(options: IntegrationAppClientOptions);
+    get self(): SelfAccessor;
+    get flows(): FlowsAccessor;
+    open({ onClose }?: OpenIntegrationAppConfigurationOptions): Promise<void>;
+    action(selector: string | ActionSelector): ActionAccessor;
+    get actions(): ActionsAccessor;
+    screen(selector: string | ScreenSelector): ScreenAccessor;
+    get screens(): ScreensAccessor;
+    actionInstance(selector: string | ActionInstanceSelector): ActionInstanceAccessor;
+    get actionInstances(): ActionInstancesAccessor;
+    flow(selector: string | FlowSelector): FlowAccessor;
+    get flowInstances(): FlowInstancesAccessor;
+    flowInstance(selector: string | FlowInstanceSelector): FlowInstanceAccessor;
+    get dataSourceInstances(): DataSourceInstancesAccessor;
+    get dataSources(): DataSourcesAccessor;
+    dataSource(selector: string | DataSourceSelector): DataSourceAccessor;
+    dataSourceInstance(selector: string | DataSourceInstanceSelector): DataSourceInstanceAccessor;
+    get fieldMappings(): FieldMappingsAccessor;
+    fieldMapping(selector: string | FieldMappingSelector): FieldMappingAccessor;
+    get fieldMappingInstances(): FieldMappingInstancesAccessor;
+    fieldMappingInstance(selector: string | FieldMappingInstanceSelector): FieldMappingInstanceAccessor;
+    get dataLinkTables(): DataLinkTablesAccessor;
+    dataLinkTable(idOrKey: string): DataLinkTableAccessor;
+    get dataLinkTableInstances(): DataLinkTableInstancesAccessor;
+    dataLinkTableInstance(selector: string | DataLinkTableInstanceSelector): DataLinkTableInstanceAccessor;
+    get integrations(): IntegrationsAccessor;
+    externalEventSubscriptions(): ExternalEventSubscriptionsAccessor;
+    externalEventSubscription(id: string): ExternalEventSubscriptionAccessor;
+    integration(identifier: string): IntegrationAccessor;
+    get connections(): ConnectionsAccessor;
+    connection(connectionSelector: string): ConnectionAccessor;
+    get appEventTypes(): AppEventTypesAccessor;
+    appEventType(id: string): AppEventTypeAccessor;
+    get appEventSubscriptions(): AppEventSubscriptionsAccessor;
+    appEventSubscription(selector: string | AppEventSubscriptionSelector): AppEventSubscriptionAccessor;
+    get appEvents(): AppEventsAccessor;
+    get flowRuns(): FlowRunsAccessor;
+    flowRun(id: string): FlowRunAccessor;
+    get appDataSchemas(): AppDataSchemasAccessor;
+    appDataSchema(id: string): AppDataSchemaAccessor;
+    get appDataSchemaInstances(): AppDataSchemaInstancesAccessor;
+    appDataSchemaInstance(selector: string | AppDataSchemaInstanceSelector): AppDataSchemaInstanceAccessor;
+    customer(selector: string | CustomerSelector): CustomerAccessor;
+    get customers(): CustomersAccessor;
+    scenario(selector: string): ScenarioAccessor;
+    get scenarios(): ScenariosAccessor;
+    connectionRequest(connectionId: string, uri: string, data?: any): Promise<any>;
+}
+export {};