@membranehq/sdk 0.6.0 → 0.7.0

package/dist/dts/accessors/action-instances-accessors.d.ts

@@ -1,4 +1,4 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { ElementInstanceAccessor, ElementInstanceListAccessor } from './base-accessors';
 import { InstanceKeyQuery } from '../integration-elements/common';
@@ -8,26 +8,26 @@ import { ActionRunResponse } from '../workspace-elements/api/actions-api';
 export interface OpenActionConfigurationOptions extends OpenConfigurationOptions {
 }
 export declare class ActionInstancesAccessor extends ElementInstanceListAccessor<ActionInstance, FindActionInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class ActionInstanceAccessor extends ElementInstanceAccessor<ActionInstance, ActionInstanceSelector, CreateActionInstanceRequest, UpdateActionInstanceRequest> {
-    client: IntegrationAppApiClient;
-    constructor(client: IntegrationAppApiClient, selector: string | ActionInstanceSelector);
+    client: MembraneApiClient;
+    constructor(client: MembraneApiClient, selector: string | ActionInstanceSelector);
     setup(): Promise<void>;
     reset(): Promise<void>;
     run(input?: any): Promise<ActionRunResponse>;
     open({ onClose }?: OpenActionConfigurationOptions): Promise<void>;
 }
 export declare class ConnectionLevelActionAccessor extends ConnectionLevelElementAccessor<ActionInstance, UpdateActionInstanceRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
     actionSelector: string;
     query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, actionSelector: string, query: InstanceKeyQuery);
+    constructor(client: MembraneApiClient, connectionSelector: string, actionSelector: string, query: InstanceKeyQuery);
     run(input?: any): Promise<ActionRunResponse>;
 }
 export declare class ConnectionLevelActionsAccessor extends ConnectionLevelElementsListAccessor<ActionInstance, ListActionInstancesForConnectionQuery> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+    constructor(client: MembraneApiClient, connectionSelector: string);
 }

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

@@ -1,23 +1,23 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { IntegrationLevelElementAccessor, IntegrationLevelElementsListAccessor } from '../integration-elements/integration-level-element.accessor';
 import { Action, ActionSelector, CreateActionRequest, FindActionsQuery, UpdateActionRequest } from '../workspace-elements/api/actions-api';
 export declare class ActionsAccessor extends ElementListAccessor<Action, FindActionsQuery, CreateActionRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class ActionAccessor extends ElementAccessor<Action, UpdateActionRequest, ActionSelector> {
-    constructor(client: IntegrationAppApiClient, selector: ActionSelector | string);
+    constructor(client: MembraneApiClient, selector: ActionSelector | string);
     apply(integrationKeys: string[]): Promise<Action[]>;
     reset(): Promise<any>;
 }
 export declare class IntegrationLevelActionAccessor extends IntegrationLevelElementAccessor<Action, UpdateActionRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
     actionSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, actionSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string, actionSelector: string);
 }
 export declare class IntegrationLevelActionsListAccessor extends IntegrationLevelElementsListAccessor<Action, Omit<FindActionsQuery, 'integrationId'>, Omit<CreateActionRequest, 'integrationId'>> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string);
 }

package/dist/dts/accessors/app-data-schema-instances-accessors.d.ts

@@ -1,12 +1,12 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementInstanceAccessor, ElementInstanceListAccessor } from './base-accessors';
 import { AppDataSchemaInstanceSelector, FindAppDataSchemaInstancesQuery, CreateAppDataSchemaInstanceRequest, UpdateAppDataSchemaInstanceRequest } from '../workspace-elements/api';
 import { AppDataSchemaInstance } from '../workspace-elements/api/app-data-schema-instances-api';
 export declare class AppDataSchemaInstancesAccessor extends ElementInstanceListAccessor<AppDataSchemaInstance, FindAppDataSchemaInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class AppDataSchemaInstanceAccessor extends ElementInstanceAccessor<AppDataSchemaInstance, AppDataSchemaInstanceSelector, UpdateAppDataSchemaInstanceRequest, CreateAppDataSchemaInstanceRequest> {
     private client;
-    constructor(client: IntegrationAppApiClient, selector: string | AppDataSchemaInstanceSelector);
+    constructor(client: MembraneApiClient, selector: string | AppDataSchemaInstanceSelector);
     setup(): Promise<void>;
 }

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

@@ -1,10 +1,10 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { CreateAppDataSchemaRequest, FindAppDataSchemasQuery, UpdateAppDataSchemaRequest } from '../workspace-elements/api';
 import { BaseAppDataSchema } from '../workspace-elements/base/app-data-schemas';
 export declare class AppDataSchemasAccessor extends ElementListAccessor<BaseAppDataSchema, FindAppDataSchemasQuery, CreateAppDataSchemaRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class AppDataSchemaAccessor extends ElementAccessor<BaseAppDataSchema, UpdateAppDataSchemaRequest> {
-    constructor(client: IntegrationAppApiClient, idOrKey: string);
+    constructor(client: MembraneApiClient, idOrKey: string);
 }

package/dist/dts/accessors/app-event-subscriptions-accessors.d.ts

@@ -1,11 +1,11 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementInstanceAccessor, ElementInstanceListAccessor } from './base-accessors';
 import { AppEventSubscriptionSelector, UpdateAppEventSubscriptionRequest, FindAppEventSubscriptionsQuery } from '../workspace-elements/api';
 import { AppEventSubscription } from '../workspace-elements/api/app-event-subscriptions-api';
 export declare class AppEventSubscriptionsAccessor extends ElementInstanceListAccessor<AppEventSubscription, FindAppEventSubscriptionsQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class AppEventSubscriptionAccessor extends ElementInstanceAccessor<AppEventSubscription, AppEventSubscriptionSelector, UpdateAppEventSubscriptionRequest, UpdateAppEventSubscriptionRequest> {
-    constructor(client: IntegrationAppApiClient, selector: string | AppEventSubscriptionSelector);
+    constructor(client: MembraneApiClient, selector: string | AppEventSubscriptionSelector);
     subscribe(): Promise<void>;
 }

package/dist/dts/accessors/app-event-types-accessors.d.ts

@@ -1,10 +1,10 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { CreateAppEventTypeRequest, FindAppEventTypesQuery, UpdateAppEventTypeRequest } from '../workspace-elements/api';
 import { BaseAppEventType } from '../workspace-elements/base/app-event-types';
 export declare class AppEventTypesAccessor extends ElementListAccessor<BaseAppEventType, FindAppEventTypesQuery, CreateAppEventTypeRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class AppEventTypeAccessor extends ElementAccessor<BaseAppEventType, UpdateAppEventTypeRequest> {
-    constructor(client: IntegrationAppApiClient, idOrKey: string);
+    constructor(client: MembraneApiClient, idOrKey: string);
 }

package/dist/dts/accessors/base-accessors.d.ts

@@ -1,4 +1,4 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { PaginationResponse } from '../entity-repository';
 import { WorkspaceElementType } from '../workspace-elements/types';
 export interface BaseElementInstance {
@@ -23,12 +23,12 @@ type SelectorType = {
 } | string;
 export declare class ElementAccessor<Element, UpdateRequest, Selector extends SelectorType = string> {
     protected options: {
-        client: IntegrationAppApiClient;
+        client: MembraneApiClient;
         path: string;
         selector: string | Selector;
     };
     constructor(options: {
-        client: IntegrationAppApiClient;
+        client: MembraneApiClient;
         path: string;
         selector: string | Selector;
     });
@@ -43,29 +43,29 @@ export declare class ElementAccessor<Element, UpdateRequest, Selector extends Se
 export declare class ElementListAccessor<Element, FindQuery, CreateRequest> {
     private client;
     private path;
-    constructor(client: IntegrationAppApiClient, path: string);
+    constructor(client: MembraneApiClient, 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;
+    protected client: MembraneApiClient;
     private path;
-    constructor(client: IntegrationAppApiClient, path: string);
+    constructor(client: MembraneApiClient, 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;
+        client: MembraneApiClient;
         instancePath: string;
         selector: string | Selector;
         type?: WorkspaceElementType;
     };
     private id;
     constructor(options: {
-        client: IntegrationAppApiClient;
+        client: MembraneApiClient;
         instancePath: string;
         selector: string | Selector;
         type?: WorkspaceElementType;

package/dist/dts/accessors/connections-accessors.d.ts

@@ -3,7 +3,7 @@ import { ElementInstanceListAccessor } from './base-accessors';
 import { ConnectionLevelDataSourceAccessor, ConnectionLevelDataSourcesAccessor } from './data-sources-accessors';
 import { ConnectionLevelFieldMappingAccessor, ConnectionLevelFieldMappingsAccessor } from './field-mapping-instances-accessors';
 import { ConnectionLevelFlowAccessor, ConnectionLevelFlowsAccessor } from './flow-instances-accessors';
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { InstanceKeyQuery } from '../integration-elements/common';
 import { Connection, CreateConnectionRequest, FindConnectionsQuery, UpdateConnectionRequest } from '../workspace-elements/api/connections-api';
@@ -11,13 +11,13 @@ import { ConnectorSpec } from '../workspace-elements/base/connectors';
 import { OperationRunRequest, OperationRunResponse, OperationSpec } from '../workspace-elements/base/connectors/operations/types';
 import { DataCollectionSpec, DataCollectionCreateRequest, DataCollectionCreateResponse, DataCollectionDeleteRequest, DataCollectionDeleteResponse, DataCollectionFindByIdRequest, DataCollectionFindByIdResponse, DataCollectionListRequest, DataCollectionListResponse, DataCollectionMatchRequest, DataCollectionMatchResponse, DataCollectionSearchRequest, DataCollectionSearchResponse, DataCollectionUpdateRequest, DataCollectionUpdateResponse } from '../workspace-elements/base/data-collections';
 export declare class ConnectionsAccessor extends ElementInstanceListAccessor<Connection, FindConnectionsQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
     create(data: CreateConnectionRequest): Promise<Connection>;
 }
 export declare class ConnectionAccessor {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+    constructor(client: MembraneApiClient, connectionSelector: string);
     get actions(): ConnectionLevelActionsAccessor;
     action(actionSelector: string, query?: InstanceKeyQuery): ConnectionLevelActionAccessor;
     get flows(): ConnectionLevelFlowsAccessor;
@@ -109,19 +109,19 @@ export declare class ConnectionAccessor {
     getPath(subpath?: string, query?: Record<string, any>): string;
 }
 export declare class ConnectionOperationAccessor {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionAccessor: ConnectionAccessor;
     key: string;
-    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string);
+    constructor(client: MembraneApiClient, connectionAccessor: ConnectionAccessor, key: string);
     get(): Promise<OperationSpec>;
     run(request?: OperationRunRequest): Promise<OperationRunResponse>;
 }
 export declare class ConnectionDataCollectionAccessor {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionAccessor: ConnectionAccessor;
     key: string;
     parameters: Record<string, any>;
-    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string, parameters: Record<string, any>);
+    constructor(client: MembraneApiClient, connectionAccessor: ConnectionAccessor, key: string, parameters: Record<string, any>);
     get(): Promise<DataCollectionSpec>;
     findById(request?: DataCollectionFindByIdRequest): Promise<DataCollectionFindByIdResponse>;
     list(request?: DataCollectionListRequest): Promise<DataCollectionListResponse>;

package/dist/dts/accessors/customers-accessors.d.ts

@@ -1,15 +1,15 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { Customer, CreateCustomerRequest, FindCustomersQuery, UpdateCustomerRequest, CustomerSelector } from '../workspace-elements/api/customers-api';
 export declare class CustomersAccessor extends ElementListAccessor<Customer, FindCustomersQuery, CreateCustomerRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class CustomerAccessor extends ElementAccessor<Customer, UpdateCustomerRequest, CustomerSelector> {
-    constructor(client: IntegrationAppApiClient, selector: CustomerSelector | string);
+    constructor(client: MembraneApiClient, selector: CustomerSelector | string);
 }
 export declare class UsersAccessor extends CustomersAccessor {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class UserAccessor extends CustomerAccessor {
-    constructor(client: IntegrationAppApiClient, selector: string);
+    constructor(client: MembraneApiClient, selector: string);
 }

package/dist/dts/accessors/data-link-table-instances-accessors.d.ts

@@ -1,13 +1,13 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementInstanceAccessor, ElementInstanceListAccessor } from './base-accessors';
 import { CreateDataLinkRequest, DataLinkTableInstanceSelector, DeleteDataLinkRequest, FindDataLinkTableInstancesQuery, FindDataLinksInTableQuery, FindDataLinksResponse, UpdateDataLinkTableInstanceRequest } from '../workspace-elements/api';
 import { DataLinkTableInstance } from '../workspace-elements/api/data-link-table-instances-api';
 export declare class DataLinkTableInstancesAccessor extends ElementInstanceListAccessor<DataLinkTableInstance, FindDataLinkTableInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class DataLinkTableInstanceAccessor extends ElementInstanceAccessor<DataLinkTableInstance, DataLinkTableInstanceSelector, UpdateDataLinkTableInstanceRequest, UpdateDataLinkTableInstanceRequest> {
     private client;
-    constructor(client: IntegrationAppApiClient, selector: string | DataLinkTableInstanceSelector);
+    constructor(client: MembraneApiClient, selector: string | DataLinkTableInstanceSelector);
     findLinks(query?: FindDataLinksInTableQuery): Promise<FindDataLinksResponse>;
     createLink(data: CreateDataLinkRequest): Promise<void>;
     deleteLink(data: DeleteDataLinkRequest): Promise<void>;

package/dist/dts/accessors/data-link-tables-accessors.d.ts

@@ -1,10 +1,10 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { CreateDataLinkTableRequest, FindDataLinkTablesQuery, UpdateDataLinkTableRequest } from '../workspace-elements/api';
 import { BaseDataLinkTable } from '../workspace-elements/base/data-link-tables';
 export declare class DataLinkTablesAccessor extends ElementListAccessor<BaseDataLinkTable, FindDataLinkTablesQuery, CreateDataLinkTableRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class DataLinkTableAccessor extends ElementAccessor<BaseDataLinkTable, UpdateDataLinkTableRequest> {
-    constructor(client: IntegrationAppApiClient, idOrKey: string);
+    constructor(client: MembraneApiClient, idOrKey: string);
 }

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

@@ -1,4 +1,4 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { ElementAccessor, ElementInstanceAccessor, ElementInstanceListAccessor, ElementListAccessor } from './base-accessors';
 import { InstanceKeyQuery } from '../integration-elements/common';
@@ -10,20 +10,20 @@ import { DataCollectionCreateRequest, DataCollectionCreateResponse, DataCollecti
 export interface OpenDataSourceConfigurationOptions extends OpenConfigurationOptions {
 }
 export declare class DataSourcesAccessor extends ElementListAccessor<DataSource, FindDataSourcesQuery, CreateDataSourceRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class DataSourceAccessor extends ElementAccessor<DataSource, UpdateDataSourceRequest, DataSourceSelector> {
-    constructor(client: IntegrationAppApiClient, selector: DataSourceSelector | string);
+    constructor(client: MembraneApiClient, 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);
+    constructor(client: MembraneApiClient);
 }
 export declare class DataSourceInstanceAccessor extends ElementInstanceAccessor<DataSourceInstance, DataSourceInstanceSelector, CreateDataSourceInstanceRequest, UpdateDataSourceInstanceRequest> {
-    client: IntegrationAppApiClient;
-    constructor(client: IntegrationAppApiClient, selector: string | DataSourceInstanceSelector);
+    client: MembraneApiClient;
+    constructor(client: MembraneApiClient, selector: string | DataSourceInstanceSelector);
     setup(): Promise<void>;
     reset(): Promise<void>;
     openConfiguration({ onClose }?: OpenDataSourceConfigurationOptions): Promise<void>;
@@ -39,26 +39,26 @@ export declare class DataSourceInstanceAccessor extends ElementInstanceAccessor<
     findRecords(request?: DataCollectionFindRequest): Promise<DataCollectionFindResponse>;
 }
 export declare class IntegrationLevelDataSourceAccessor extends IntegrationLevelElementAccessor<DataSource, UpdateDataSourceRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
     dataSourceSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, dataSourceSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string, dataSourceSelector: string);
 }
 export declare class IntegrationLevelDataSourcesListAccessor extends IntegrationLevelElementsListAccessor<DataSource, ListDataSourcesForIntegrationQuery, Omit<CreateDataSourceRequest, 'integrationId'>> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string);
 }
 export declare class ConnectionLevelDataSourceAccessor extends ConnectionLevelElementAccessor<DataSourceInstance, UpdateDataSourceInstanceRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
     dataSourceSelector: string;
     query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, dataSourceSelector: string, query: InstanceKeyQuery);
+    constructor(client: MembraneApiClient, connectionSelector: string, dataSourceSelector: string, query: InstanceKeyQuery);
     openConfiguration(options?: OpenDataSourceConfigurationOptions): Promise<void>;
 }
 export declare class ConnectionLevelDataSourcesAccessor extends ConnectionLevelElementsListAccessor<DataSource, ListDataSourceInstancesForConnectionQuery> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+    constructor(client: MembraneApiClient, connectionSelector: string);
 }

package/dist/dts/accessors/external-event-subscriptions-accessors.d.ts

@@ -1,14 +1,14 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementInstanceListAccessor } from './base-accessors';
 import { ExternalEventSubscription } from '../workspace-elements/api/external-event-subscriptions-api';
 import { FindExternalEventSubscriptionsQuery } from '../workspace-elements/api/external-events-api';
 export declare class ExternalEventSubscriptionsAccessor extends ElementInstanceListAccessor<ExternalEventSubscription, FindExternalEventSubscriptionsQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class ExternalEventSubscriptionAccessor {
     private client;
     private id;
-    constructor(client: IntegrationAppApiClient, id: string);
+    constructor(client: MembraneApiClient, id: string);
     get(): Promise<ExternalEventSubscription>;
     setup(): Promise<void>;
     subscribe(): Promise<void>;

package/dist/dts/accessors/field-mapping-instances-accessors.d.ts

@@ -1,4 +1,4 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { ElementInstanceAccessor, ElementInstanceListAccessor } from './base-accessors';
 import { InstanceKeyQuery } from '../integration-elements/common';
@@ -7,25 +7,25 @@ import { CreateFieldMappingInstanceRequest, FieldMappingInstance, FieldMappingIn
 export interface OpenFieldMappingInstanceConfigurationOptions extends OpenConfigurationOptions {
 }
 export declare class FieldMappingInstancesAccessor extends ElementInstanceListAccessor<FieldMappingInstance, FindFieldMappingInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class FieldMappingInstanceAccessor extends ElementInstanceAccessor<FieldMappingInstance, FieldMappingInstanceSelector, CreateFieldMappingInstanceRequest, UpdateFieldMappingInstanceRequest> {
     private client;
-    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingInstanceSelector);
+    constructor(client: MembraneApiClient, selector: string | FieldMappingInstanceSelector);
     setup(): Promise<void>;
     reset(): Promise<void>;
     openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
 }
 export declare class ConnectionLevelFieldMappingAccessor extends ConnectionLevelElementAccessor<FieldMappingInstance, UpdateFieldMappingInstanceRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
     fieldMappingSelector: string;
     query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, fieldMappingSelector: string, query: InstanceKeyQuery);
+    constructor(client: MembraneApiClient, connectionSelector: string, fieldMappingSelector: string, query: InstanceKeyQuery);
     openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
 }
 export declare class ConnectionLevelFieldMappingsAccessor extends ConnectionLevelElementsListAccessor<FieldMappingInstance, ListFieldMappingInstancesForConnectionQuery> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+    constructor(client: MembraneApiClient, connectionSelector: string);
 }

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

@@ -1,25 +1,25 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { IntegrationLevelElementAccessor, IntegrationLevelElementsListAccessor } from '../integration-elements/integration-level-element.accessor';
 import { CreateFieldMappingRequest, FieldMapping, FindFieldMappingsQuery, FieldMappingSelector, ListFieldMappingsForIntegrationQuery, UpdateFieldMappingRequest } from '../workspace-elements/api/field-mappings-api';
 export declare class FieldMappingsAccessor extends ElementListAccessor<FieldMapping, FindFieldMappingsQuery, CreateFieldMappingRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class FieldMappingAccessor extends ElementAccessor<FieldMapping, UpdateFieldMappingRequest, FieldMappingSelector> {
-    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingSelector);
+    constructor(client: MembraneApiClient, selector: string | FieldMappingSelector);
     getAppSchema(): Promise<any>;
     apply(integrationKeys: string[]): Promise<FieldMapping[]>;
     setup(): Promise<any>;
     reset(): Promise<any>;
 }
 export declare class IntegrationLevelFieldMappingAccessor extends IntegrationLevelElementAccessor<FieldMapping, UpdateFieldMappingRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
     fieldMappingSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, fieldMappingSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string, fieldMappingSelector: string);
 }
 export declare class IntegrationLevelFieldMappingsListAccessor extends IntegrationLevelElementsListAccessor<FieldMapping, ListFieldMappingsForIntegrationQuery, Omit<CreateFieldMappingRequest, 'integrationId'>> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string);
 }

package/dist/dts/accessors/flow-instances-accessors.d.ts

@@ -1,4 +1,4 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { ElementInstanceAccessor, ElementInstanceListAccessor } from './base-accessors';
 import { InstanceKeyQuery } from '../integration-elements/common';
@@ -12,13 +12,13 @@ export interface OpenFlowInstanceConfigurationOptions extends OpenConfigurationO
 export interface OpenFlowInstanceEditorOptions extends OpenConfigurationOptions {
 }
 export declare class FlowInstancesAccessor extends ElementInstanceListAccessor<FlowInstance, FindFlowInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
     create(data: CreateFlowInstanceRequest): Promise<FlowInstance>;
 }
 export declare class FlowInstanceAccessor extends ElementInstanceAccessor<FlowInstance, FlowInstanceSelector, CreateFlowInstanceRequest, UpdateFlowInstanceRequest> {
-    protected client: IntegrationAppApiClient;
+    protected client: MembraneApiClient;
     protected selector: FlowInstanceSelector | string;
-    constructor(client: IntegrationAppApiClient, selector: FlowInstanceSelector | string);
+    constructor(client: MembraneApiClient, selector: FlowInstanceSelector | string);
     enable(): Promise<FlowInstance>;
     disable(): Promise<FlowInstance>;
     updateToLatestFlow(): Promise<FlowInstance>;
@@ -33,11 +33,11 @@ export declare class FlowInstanceAccessor extends ElementInstanceAccessor<FlowIn
     run(options?: RunFlowOptions): Promise<FlowRun>;
 }
 export declare class ConnectionLevelFlowAccessor extends ConnectionLevelElementAccessor<FlowInstance, UpdateFlowInstanceRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
     flowSelector: string;
     query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, flowSelector: string, query: InstanceKeyQuery);
+    constructor(client: MembraneApiClient, connectionSelector: string, flowSelector: string, query: InstanceKeyQuery);
     enable(): Promise<FlowInstance>;
     disable(): Promise<FlowInstance>;
     run(options: {
@@ -48,7 +48,7 @@ export declare class ConnectionLevelFlowAccessor extends ConnectionLevelElementA
     openEditor(options?: OpenFlowInstanceEditorOptions): Promise<void>;
 }
 export declare class ConnectionLevelFlowsAccessor extends ConnectionLevelElementsListAccessor<FlowInstance, ListFlowInstancesForConnectionQuery> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+    constructor(client: MembraneApiClient, connectionSelector: string);
 }

package/dist/dts/accessors/flow-runs-accessors.d.ts

@@ -1,11 +1,11 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { CreateFlowRunRequest, FindFlowRunsQuery, FindFlowRunsResponse, FlowRun } from '../workspace-elements/api/flow-runs-api';
 export interface OpenFlowRunEditorOptions extends OpenConfigurationOptions {
 }
 export declare class FlowRunsAccessor {
     private readonly client;
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
     find(query: FindFlowRunsQuery): Promise<FindFlowRunsResponse>;
     create(request: CreateFlowRunRequest): Promise<FlowRun>;
 }
@@ -13,7 +13,7 @@ export declare class FlowRunAccessor {
     private readonly client;
     id: string;
     private baseUri;
-    constructor(client: IntegrationAppApiClient, id: string);
+    constructor(client: MembraneApiClient, id: string);
     get(): Promise<FlowRun>;
     stop(): Promise<void>;
     getOutput(): Promise<any>;

package/dist/dts/accessors/flows-accessors.d.ts

@@ -1,23 +1,23 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { IntegrationLevelElementAccessor, IntegrationLevelElementsListAccessor } from '../integration-elements/integration-level-element.accessor';
 import { CreateFlowRequest, FindFlowsQuery, Flow, FlowSelector, ListFlowsForIntegrationQuery, UpdateFlowRequest } from '../workspace-elements/api/flows-api';
 export declare class FlowsAccessor extends ElementListAccessor<Flow, FindFlowsQuery, CreateFlowRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class FlowAccessor extends ElementAccessor<Flow, UpdateFlowRequest, FlowSelector> {
-    constructor(client: IntegrationAppApiClient, selector: FlowSelector | string);
+    constructor(client: MembraneApiClient, selector: FlowSelector | string);
     apply(integrationKeys: string[]): Promise<Flow[]>;
     reset(): Promise<Flow>;
 }
 export declare class IntegrationLevelFlowAccessor extends IntegrationLevelElementAccessor<Flow, UpdateFlowRequest> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
     flowSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, flowSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string, flowSelector: string);
 }
 export declare class IntegrationLevelFlowsListAccessor extends IntegrationLevelElementsListAccessor<Flow, ListFlowsForIntegrationQuery, Omit<CreateFlowRequest, 'integrationId'>> {
-    client: IntegrationAppApiClient;
+    client: MembraneApiClient;
     integrationSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string);
 }

package/dist/dts/accessors/integrations-accessors.d.ts

@@ -3,7 +3,7 @@ import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { IntegrationLevelDataSourceAccessor, IntegrationLevelDataSourcesListAccessor } from './data-sources-accessors';
 import { IntegrationLevelFieldMappingAccessor, IntegrationLevelFieldMappingsListAccessor } from './field-mappings-accessors';
 import { IntegrationLevelFlowAccessor, IntegrationLevelFlowsListAccessor } from './flows-accessors';
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { Connection } from '../workspace-elements/api/connections-api';
 import { CreateIntegrationRequest, UpdateIntegrationRequest, FindIntegrationsQuery, OpenNewConnectionOptions, Integration } from '../workspace-elements/api/integrations-api';
@@ -13,13 +13,13 @@ import { DataCollectionListItem, DataCollectionSpec } from '../workspace-element
 interface OpenIntegrationUIIntegrationConfigurationOptions extends OpenConfigurationOptions {
 }
 export declare class IntegrationsAccessor extends ElementListAccessor<Integration, FindIntegrationsQuery, CreateIntegrationRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class IntegrationAccessor extends ElementAccessor<Integration, UpdateIntegrationRequest> {
     private client;
     private integrationSelector;
     baseUri: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+    constructor(client: MembraneApiClient, integrationSelector: string);
     get actions(): IntegrationLevelActionsListAccessor;
     action(actionSelector: string): IntegrationLevelActionAccessor;
     get flows(): IntegrationLevelFlowsListAccessor;

package/dist/dts/accessors/scenarios-accessors.d.ts

@@ -1,9 +1,9 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { CreateScenarioRequest, FindScenariosQuery, Scenario, UpdateScenarioRequest } from '../workspace-elements/api/scenarios-api';
 export declare class ScenariosAccessor extends ElementListAccessor<Scenario, FindScenariosQuery, CreateScenarioRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class ScenarioAccessor extends ElementAccessor<Scenario, UpdateScenarioRequest> {
-    constructor(client: IntegrationAppApiClient, selector: string);
+    constructor(client: MembraneApiClient, selector: string);
 }

package/dist/dts/accessors/screens-accessors.d.ts

@@ -1,9 +1,9 @@
-import { IntegrationAppApiClient } from '../api-client';
+import { MembraneApiClient } from '../api-client';
 import { ElementAccessor, ElementListAccessor } from './base-accessors';
 import { CreateScreenRequest, FindScreensQuery, Screen, UpdateScreenRequest, ScreenSelector } from '../workspace-elements/api/screens-api';
 export declare class ScreensAccessor extends ElementListAccessor<Screen, FindScreensQuery, CreateScreenRequest> {
-    constructor(client: IntegrationAppApiClient);
+    constructor(client: MembraneApiClient);
 }
 export declare class ScreenAccessor extends ElementAccessor<Screen, UpdateScreenRequest, ScreenSelector> {
-    constructor(client: IntegrationAppApiClient, selector: ScreenSelector | string);
+    constructor(client: MembraneApiClient, selector: ScreenSelector | string);
 }