@membranehq/sdk 0.3.0 → 0.4.0

package/dist/dts/workspace-elements/api/data-source-instances-api.d.ts

@@ -0,0 +1,12 @@
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { BaseDataSourceInstance } from '../base/data-source-instances';
+import { BaseDataSource } from '../base/data-sources';
+import { BaseIntegration } from '../base/integrations';
+export interface DataSourceInstance extends BaseDataSourceInstance {
+    user?: BaseCustomer;
+    dataSource?: BaseDataSource;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+}
+export type DataSourceInstanceApiResponse = DataSourceInstance;

package/dist/dts/{data-sources/api.d.ts → workspace-elements/api/data-sources-api.d.ts}

@@ -1,8 +1,10 @@
-import { ElementInstanceSelector } from '../accessors';
-import { ConnectionSelector } from '../connections';
-import { PaginationQuery, PaginationResponse } from '../entity-repository';
-import { FlowInstanceSelector } from '../flows';
-import { DataSourceInstance } from '.';
+import { ConnectionSelector } from './connections-api';
+import { DataSourceInstance } from './data-source-instances-api';
+import { FlowInstanceSelector } from './flows-api';
+import { ElementInstanceSelector, IntegrationSpecificElementSelector } from '../../accessors';
+import { PaginationQuery, PaginationResponse } from '../../entity-repository';
+import { BaseDataSource } from '../base/data-sources';
+import { AppliedToIntegrations, BaseIntegration } from '../base/integrations';
 export interface ListDataSourcesForIntegrationQuery extends PaginationQuery {
     universalDataSourceId?: string | 'null';
 }
@@ -31,6 +33,8 @@ export type UpdateDataSourceRequest = {
     rootPath?: string;
     defaultPath?: string;
 };
+export interface DataSourceSelector extends IntegrationSpecificElementSelector {
+}
 export interface DataSourceInstanceSelector extends ConnectionSelector, FlowInstanceSelector, ElementInstanceSelector {
     dataSourceKey?: string;
     dataSourceId?: string;
@@ -88,3 +92,8 @@ export interface FindDataSourceInstanceSyncsQuery extends ListDataSourceInstance
     integrationId?: string;
     dataSourceInstanceId?: string;
 }
+export interface DataSource extends BaseDataSource {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<DataSource>;
+}
+export type DataSourceApiResponse = DataSource;

package/dist/dts/workspace-elements/api/external-event-log-records-api.d.ts

@@ -0,0 +1,19 @@
+import { CommonListElementsQuery } from '../../entity-repository';
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { ExternalEventLogStatus, BaseExternalEventLogRecord } from '../base/external-event-log-records';
+import { BaseExternalEventSubscription } from '../base/external-event-subscriptions';
+import { BaseIntegration } from '../base/integrations';
+export interface ListExternalEventLogRecordsQuery extends CommonListElementsQuery {
+    connectionId?: string;
+    integrationId?: string;
+    externalEventSubscriptionId?: string;
+    status?: ExternalEventLogStatus;
+}
+export interface ExternalEventLogRecord extends BaseExternalEventLogRecord {
+    user?: BaseCustomer;
+    externalEventSubscription?: BaseExternalEventSubscription;
+    integration?: BaseIntegration;
+    connection?: BaseConnection;
+}
+export type ExternalEventLogRecordApiResponse = ExternalEventLogRecord;

package/dist/dts/workspace-elements/api/external-event-pulls-api.d.ts

@@ -0,0 +1,19 @@
+import { CommonListElementsQuery } from '../../entity-repository';
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { ExternalEventPullStatus, BaseExternalEventPull } from '../base/external-event-pulls';
+import { BaseExternalEventSubscription } from '../base/external-event-subscriptions';
+import { BaseIntegration } from '../base/integrations';
+export interface ListExternalEventPullsQuery extends CommonListElementsQuery {
+    connectionId?: string;
+    integrationId?: string;
+    externalEventSubscriptionId?: string;
+    status?: ExternalEventPullStatus;
+}
+export interface ExternalEventPull extends BaseExternalEventPull {
+    user?: BaseCustomer;
+    externalEventSubscription?: BaseExternalEventSubscription;
+    integration?: BaseIntegration;
+    connection?: BaseConnection;
+}
+export type ExternalEventPullApiResponse = ExternalEventPull;

package/dist/dts/workspace-elements/api/external-event-subscriptions-api.d.ts

@@ -0,0 +1,10 @@
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { BaseExternalEventSubscription } from '../base/external-event-subscriptions';
+import { BaseIntegration } from '../base/integrations';
+export interface ExternalEventSubscription extends BaseExternalEventSubscription {
+    user?: BaseCustomer;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+}
+export type ExternalEventSubscriptionApiResponse = ExternalEventSubscription;

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

@@ -0,0 +1,73 @@
+import { PaginationQuery } from '../../entity-repository';
+import { ExternalEventLogStatus } from '../base/external-event-log-records';
+import { ExternalEventUnitConfig } from '../base/external-events';
+import { AppliedToIntegrations } from '../base/integrations';
+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;
+}
+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 ExternalEvent {
+    config?: ExternalEventUnitConfig;
+    appliedToIntegrations?: AppliedToIntegrations<ExternalEvent>;
+}
+export type ExternalEventApiResponse = ExternalEvent;

package/dist/dts/workspace-elements/api/field-mapping-instances-api.d.ts

@@ -0,0 +1,41 @@
+import { ConnectionSelector } from './connections-api';
+import { DataSourceInstance } from './data-source-instances-api';
+import { FlowInstanceSelector } from './flows-api';
+import { ElementInstanceSelector } from '../../accessors';
+import { CommonInstancesListQuery, CommonIntegrationOrConnectionQuery } from '../../entity-repository';
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { BaseFieldMappingInstance } from '../base/field-mapping-instances';
+import { BaseFieldMapping } from '../base/field-mappings';
+import { BaseIntegration } from '../base/integrations';
+export type ListFieldMappingInstancesForConnectionQuery = CommonInstancesListQuery & {
+    fieldMappingId?: string;
+    universalFieldMappingId?: string;
+    dataSourceInstanceId?: string;
+};
+export type FindFieldMappingInstancesQuery = ListFieldMappingInstancesForConnectionQuery & CommonIntegrationOrConnectionQuery;
+export interface CreateFieldMappingInstanceRequest {
+    connectionId: string;
+    fieldMappingId?: string;
+    instanceKey?: string;
+    importValue?: any;
+    exportValue?: any;
+}
+export interface UpdateFieldMappingInstanceRequest {
+    importValue?: any;
+    exportValue?: any;
+}
+export interface FieldMappingInstanceSelector extends ConnectionSelector, FlowInstanceSelector, ElementInstanceSelector {
+    fieldMappingKey?: string;
+    fieldMappingId?: string;
+    instanceKey?: string;
+    nodeKey?: string;
+}
+export interface FieldMappingInstance extends BaseFieldMappingInstance {
+    user?: BaseCustomer;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+    fieldMapping?: BaseFieldMapping;
+    dataSourceInstance?: DataSourceInstance;
+}
+export type FieldMappingInstanceApiResponse = FieldMappingInstance;

package/dist/dts/workspace-elements/api/field-mappings-api.d.ts

@@ -0,0 +1,39 @@
+import { IntegrationSpecificElementSelector } from '../../accessors';
+import { DataSchema } from '../../data-schema';
+import { CommonListElementsQuery } from '../../entity-repository';
+import { FieldMappingDirection, BaseFieldMapping } from '../base/field-mappings';
+import { BaseIntegration, AppliedToIntegrations } from '../base/integrations';
+export interface ListFieldMappingsForIntegrationQuery extends CommonListElementsQuery {
+    universalFieldMappingId?: string | 'null';
+}
+export interface FindFieldMappingsQuery extends ListFieldMappingsForIntegrationQuery {
+    integrationId?: string | 'null';
+}
+export interface UpdateFieldMappingRequest {
+    key?: string;
+    name?: string;
+    dataSourceKey?: string;
+    dataSourceId?: string;
+    appSchema?: DataSchema;
+    direction?: FieldMappingDirection;
+    defaultImportValue?: any;
+    exportValue?: any;
+    importValue?: any;
+    defaultExportValue?: any;
+    frozenImportFields?: any;
+    frozenExportFields?: any;
+    frozenUnifiedExportFields?: any;
+    archivedAt?: string;
+}
+export interface CreateFieldMappingRequest extends UpdateFieldMappingRequest {
+    key: string;
+    name: string;
+    integrationId?: string;
+}
+export interface FieldMappingSelector extends IntegrationSpecificElementSelector {
+}
+export interface FieldMapping extends BaseFieldMapping {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<FieldMapping>;
+}
+export type FieldMappingApiResponse = FieldMapping;

package/dist/dts/workspace-elements/api/flow-runs-api.d.ts

@@ -0,0 +1,50 @@
+import { PaginationQuery, PaginationResponse } from '../../entity-repository';
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { BaseFlowInstance } from '../base/flow-instances';
+import { BaseFlowRun } from '../base/flow-runs';
+import { BaseIntegration } from '../base/integrations';
+export declare enum FlowRunState {
+    QUEUED = "queued",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    STOPPED = "stopped",
+    FAILED = "failed"
+}
+export declare enum FlowRunLaunchedByTrigger {
+    ApiTrigger = "api-trigger",
+    ScheduleTrigger = "schedule-trigger",
+    AppEventTrigger = "app-event-trigger",
+    DataSourceTrigger = "data-source-trigger",
+    ExternalEvent = "external-event"
+}
+export interface CreateFlowRunRequest {
+    flowInstanceId: string;
+    nodeKey?: string;
+    input?: any;
+}
+export interface FindFlowRunsQuery extends PaginationQuery {
+    id?: string;
+    flowInstanceId?: string;
+    startNodeKey?: string;
+    flowId?: string;
+    universalFlowId?: string;
+    userId?: string;
+    state?: FlowRunState;
+    integrationId?: string;
+    connectionId?: string;
+    startedAfter?: string;
+}
+export interface FlowRunLaunchedBy {
+    type: FlowRunLaunchedByTrigger;
+    ids?: string[];
+}
+export interface FindFlowRunsResponse extends PaginationResponse<FlowRun> {
+}
+export interface FlowRun extends BaseFlowRun {
+    flowInstance?: BaseFlowInstance;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+    user?: BaseCustomer;
+}
+export type FlowRunApiResponse = FlowRun;

package/dist/dts/{flows/api.d.ts → workspace-elements/api/flows-api.d.ts}

@@ -1,8 +1,12 @@
-import { ElementInstanceSelector, IntegrationSpecificElementSelector } from '../accessors';
-import { ConnectionSelector } from '../connections';
-import { DataSchema } from '../data-schema';
-import { CommonInstancesListQuery, CommonIntegrationOrConnectionQuery, CommonListElementsQuery } from '../entity-repository';
-import { FlowNodeLink } from '.';
+import { ConnectionSelector } from './connections-api';
+import { ElementInstanceSelector, IntegrationSpecificElementSelector } from '../../accessors/base-accessors';
+import { DataSchema } from '../../data-schema';
+import { CommonInstancesListQuery, CommonIntegrationOrConnectionQuery, CommonListElementsQuery } from '../../entity-repository';
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { BaseFlowInstance } from '../base/flow-instances';
+import { FlowNodeLink, BaseFlow } from '../base/flows';
+import { AppliedToIntegrations, BaseIntegration } from '../base/integrations';
 export interface ListFlowsForIntegrationQuery extends CommonListElementsQuery {
     universalFlowId?: string | 'null';
 }
@@ -52,3 +56,15 @@ export interface RunFlowOptions {
     returnImmediately?: boolean;
     onUpdate?: (...args: any) => void;
 }
+export interface Flow extends BaseFlow {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<Flow>;
+}
+export type FlowApiResponse = Flow;
+export interface FlowInstance extends BaseFlowInstance {
+    user?: BaseCustomer;
+    connection?: BaseConnection;
+    flow?: Flow;
+    integration?: BaseIntegration;
+}
+export type FlowInstanceApiResponse = FlowInstance;

package/dist/dts/workspace-elements/api/index.d.ts

@@ -0,0 +1,25 @@
+export * from './actions-api';
+export * from './action-instances-api';
+export * from './action-run-log-records-api';
+export * from './connections-api';
+export * from './data-sources-api';
+export * from './data-source-instances-api';
+export * from './external-events-api';
+export * from './flows-api';
+export * from './flow-runs-api';
+export * from './integrations-api';
+export * from './scenarios-api';
+export * from './screens-api';
+export * from './customers-api';
+export * from './field-mappings-api';
+export * from './field-mapping-instances-api';
+export * from './data-link-tables-api';
+export * from './data-link-table-instances-api';
+export * from './app-event-types-api';
+export * from './app-event-subscriptions-api';
+export * from './app-data-schemas-api';
+export * from './app-data-schema-instances-api';
+export * from './external-event-log-records-api';
+export * from './external-event-pulls-api';
+export * from './external-event-subscriptions-api';
+export * from './app-events-api';

package/dist/dts/{integrations/api.d.ts → workspace-elements/api/integrations-api.d.ts}

@@ -1,6 +1,8 @@
-import { PaginationQuery, PaginationResponse, SearchQuery } from '../entity-repository';
-import { OpenConfigurationOptions } from '../iframe';
-import { Integration } from './types';
+import { PaginationQuery, PaginationResponse, SearchQuery } from '../../entity-repository';
+import { OpenConfigurationOptions } from '../../iframe';
+import { BaseConnection } from '../base/connections';
+import { ConnectorSpec } from '../base/connectors';
+import { BaseIntegration } from '../base/integrations/types';
 export interface CreateIntegrationRequest {
     name?: string;
     key: string;
@@ -22,3 +24,8 @@ export interface OpenNewConnectionOptions extends OpenConfigurationOptions {
     name?: string;
     connectorParameters?: any;
 }
+export interface Integration extends BaseIntegration {
+    connection?: BaseConnection;
+    spec?: ConnectorSpec;
+}
+export type IntegrationApiResponse = Integration;

package/dist/dts/{scenarios/types.d.ts → workspace-elements/api/scenarios-api.d.ts}

@@ -1,23 +1,20 @@
-import { CreateActionRequest } from '../actions';
-import { CreateAppDataSchemaRequest } from '../app-data-schemas';
-import { CreateAppEventTypeRequest } from '../app-events';
-import { MinimalConnector } from '../connectors';
-import { CreateDataLinkTableRequest } from '../data-links';
-import { CreateDataSourceRequest } from '../data-sources';
-import { SearchQuery, PaginationQuery } from '../entity-repository';
-import { CreateFieldMappingRequest } from '../field-mappings';
-import { CreateFlowRequest } from '../flows';
-import { IntegrationElementType } from '../integration-elements';
-import { Integration } from '../integrations';
-import { WorkspaceElement } from '../workspace-elements';
-export interface Scenario extends WorkspaceElement {
-    appId: string;
-    scenarioTemplateId?: string;
-    elements?: ScenarioElement[];
-    connectors?: MinimalConnector[];
-    todos?: ScenarioToDo[];
-    appliedToIntegrations?: Integration[];
-    archivedAt?: string;
+import { CreateActionRequest } from './actions-api';
+import { CreateAppDataSchemaRequest } from './app-data-schemas-api';
+import { CreateAppEventTypeRequest } from './app-event-types-api';
+import { CreateDataLinkTableRequest } from './data-link-tables-api';
+import { CreateDataSourceRequest } from './data-sources-api';
+import { CreateFieldMappingRequest } from './field-mappings-api';
+import { CreateFlowRequest } from './flows-api';
+import { SearchQuery, PaginationQuery } from '../../entity-repository';
+import { IntegrationElementType } from '../../integration-elements';
+import { BaseIntegration } from '../base/integrations';
+import { BaseScenario } from '../base/scenarios';
+export declare enum ScenarioTemplateCategory {
+    DataExport = "data-export",
+    DataImport = "data-import",
+    BiDirectionalSync = "bi-directional-sync",
+    UnifiedApi = "unified-api",
+    DataEnrichment = "data-enrichment"
 }
 export type ScenarioToDo = {
     name: string;
@@ -43,29 +40,6 @@ export interface UpdateScenarioRequest {
     elements?: ScenarioElement[];
     todos?: ScenarioToDo[];
 }
-export interface ScenarioTemplate {
-    id: string;
-    name: string;
-    key: string;
-    shortDescription?: string;
-    description?: string;
-    demoWorkspaceKey?: string;
-    demoAppUri?: string;
-    demoGithubRepo?: string;
-    demoVideoYoutubeUri?: string;
-    tags?: ScenarioTemplateCategory[];
-    elements?: ScenarioTemplateElements;
-    todos?: Omit<ScenarioToDo, 'isComplete'>[];
-    connectors?: MinimalConnector[];
-    handyElements?: HandyScenarioTemplateElement[];
-}
-export declare enum ScenarioTemplateCategory {
-    DataExport = "data-export",
-    DataImport = "data-import",
-    BiDirectionalSync = "bi-directional-sync",
-    UnifiedApi = "unified-api",
-    DataEnrichment = "data-enrichment"
-}
 export interface FindScenarioTemplatesQuery extends SearchQuery, PaginationQuery {
 }
 export interface CreateScenarioTemplateRequest {
@@ -113,7 +87,7 @@ export type ScenarioTemplateIntegration = {
 type WithIntegrationKeys<T> = T & {
     integrationKeys?: string[];
 };
-type ElementsExportFeilds = {
+type ElementsExportFields = {
     flows?: Record<string, WithIntegrationKeys<CreateFlowRequest>>;
     actions?: Record<string, WithIntegrationKeys<CreateActionRequest>>;
     fieldMappings?: Record<string, WithIntegrationKeys<CreateFieldMappingRequest>>;
@@ -122,8 +96,8 @@ type ElementsExportFeilds = {
     appEventTypes?: Record<string, CreateAppEventTypeRequest>;
     appDataSchemas?: Record<string, CreateAppDataSchemaRequest>;
 };
-export type ScenarioTemplateElements = ElementsExportFeilds & {
-    integrations?: Record<string, ElementsExportFeilds & {
+export type ScenarioTemplateElements = ElementsExportFields & {
+    integrations?: Record<string, ElementsExportFields & {
         connectorId: string;
     }>;
 };
@@ -142,4 +116,8 @@ export interface HandyScenarioTemplateElement {
         name: string;
     } & Record<string, any>;
 }
+export interface Scenario extends BaseScenario {
+    appliedToIntegrations?: BaseIntegration[];
+}
+export type ScenarioApiResponse = Scenario;
 export {};

package/dist/dts/{screens/types.d.ts → workspace-elements/api/screens-api.d.ts}

@@ -1,5 +1,5 @@
-import { PaginationQuery } from '../entity-repository';
-import { WorkspaceElement } from '../workspace-elements';
+import { PaginationQuery } from '../../entity-repository';
+import { BaseScreen } from '../base/screens';
 export declare enum ScreenType {
     Integration = "integration"
 }
@@ -30,8 +30,6 @@ export interface CreateScreenRequest extends UpdateScreenRequest {
 export interface FindScreensQuery extends PaginationQuery {
     type?: ScreenType;
 }
-export interface Screen extends Omit<WorkspaceElement, 'key'> {
-    type: ScreenType;
-    key?: string;
-    blocks: ScreenBlock[];
+export interface Screen extends BaseScreen {
 }
+export type ScreenApiResponse = Screen;

package/dist/dts/workspace-elements/base/action-instances/types.d.ts

@@ -0,0 +1,30 @@
+import { WorkspaceElementState } from '../../types';
+import { ActionType } from '../actions/action-types';
+export declare enum ActionDependencyType {
+    FieldMapping = "FieldMapping",
+    DataSource = "DataSource"
+}
+export interface ActionDependency {
+    type: ActionDependencyType;
+    key: string;
+    element?: any;
+}
+export interface BaseActionInstance {
+    id: string;
+    name: string;
+    revision: string;
+    parentId?: string;
+    parentRevision?: string;
+    universalParentId?: string;
+    userId: string;
+    instanceKey?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    archivedAt?: string;
+    type: ActionType;
+    inputSchema?: any;
+    config?: any;
+    outputSchema?: any;
+    isOutdated?: boolean;
+    state: WorkspaceElementState;
+}

package/dist/dts/workspace-elements/base/action-run-log-records/types.d.ts

@@ -0,0 +1,19 @@
+import { ErrorData } from '../../../errors';
+export declare enum ActionRunStatus {
+    RUNNING = "running",
+    SUCCESS = "success",
+    ERROR = "error",
+    QUEUED = "queued"
+}
+export interface BaseActionRunLogRecord {
+    id: string;
+    actionId: string;
+    integrationId: string;
+    connectionId: string;
+    input?: any;
+    output?: any;
+    status: ActionRunStatus;
+    startedAt: string;
+    completedAt?: string;
+    error?: ErrorData;
+}

package/dist/dts/{actions → workspace-elements/base/actions}/index.d.ts

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

package/dist/dts/workspace-elements/base/actions/types.d.ts

@@ -0,0 +1,25 @@
+import { ActionType } from './action-types';
+import { WorkspaceElementDependency } from '../..';
+import { DataSchema } from '../../../data-schema';
+export interface BaseAction {
+    id: string;
+    key: string;
+    name: string;
+    revision: string;
+    integrationId?: string;
+    parentId?: string;
+    parentRevision?: string;
+    isCustomized?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    archivedAt?: string;
+    type: ActionType;
+    inputSchema?: DataSchema;
+    config?: any;
+    outputMapping?: any;
+    customOutputSchema?: DataSchema;
+    defaultOutputSchema?: DataSchema;
+    transformedOutputSchema?: DataSchema;
+    outputSchema?: DataSchema;
+    dependencies?: WorkspaceElementDependency[];
+}

package/dist/dts/workspace-elements/base/app-data-schema-instances/types.d.ts

@@ -0,0 +1,12 @@
+import { ErrorData } from '../../../errors';
+import { BaseMembraneInterface } from '../../types';
+export interface BaseAppDataSchemaInstance extends BaseMembraneInterface {
+    appId: string;
+    userId: string;
+    appDataSchemaId: string;
+    appDataSchemaRevision: string;
+    instanceKey?: string;
+    schema?: any;
+    error?: ErrorData;
+    archivedAt?: string;
+}

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

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

package/dist/dts/workspace-elements/base/app-data-schemas/types.d.ts

@@ -0,0 +1,7 @@
+import { BaseMembraneInterface } from '../../types';
+export interface BaseAppDataSchema extends BaseMembraneInterface {
+    schema: any;
+    code?: string;
+    archivedAt?: string;
+    revision?: string;
+}

package/dist/dts/workspace-elements/base/app-event-subscriptions/index.d.ts

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

package/dist/dts/workspace-elements/base/app-event-subscriptions/types.d.ts

@@ -0,0 +1,15 @@
+import { DataSchema } from '../../../data-schema';
+import { HttpRequestSpec } from '../../../http-requests';
+import { BaseMembraneInterface } from '../../types';
+export interface BaseAppEventSubscription extends BaseMembraneInterface {
+    revision: string;
+    appEventTypeId: string;
+    userId: string;
+    instanceKey?: string;
+    isSubscribed: boolean;
+    schema?: DataSchema;
+    webhookUri: string;
+    subscriptionRequest: HttpRequestSpec;
+    subscriptionResponse?: any;
+    archivedAt?: string;
+}

package/dist/dts/workspace-elements/base/app-event-types/index.d.ts

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

package/dist/dts/workspace-elements/base/app-event-types/types.d.ts

@@ -0,0 +1,12 @@
+import { DataSchema } from '../../../data-schema';
+import { HttpRequestSpec } from '../../../http-requests';
+import { BaseMembraneInterface } from '../../types';
+export interface BaseAppEventType extends BaseMembraneInterface {
+    revision: string;
+    archivedAt?: string;
+    subscribeRequest?: HttpRequestSpec;
+    example?: any;
+    schema?: DataSchema;
+    globalWebhookUri: string;
+    userIdFormula?: any;
+}

package/dist/dts/workspace-elements/base/connections/index.d.ts

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