@membranehq/sdk 0.4.0 → 0.5.0

package/dist/index.js

@@ -7,9 +7,9 @@ var jsonata = require('jsonata');
 var deepEqual = require('fast-deep-equal');
 var structuredClonePolyfill = require('@ungap/structured-clone');
 var urljoin = require('url-join');
+var penpal = require('penpal');
 var v3 = require('zod-validation-error/v3');
 var qs = require('qs');
-var penpal = require('penpal');
 var axiosOriginal = require('axios');
 
 exports.ErrorType = void 0;
@@ -1346,6 +1346,42 @@ const DataSchemaSchema = zod.z.lazy(() => zod.z.object({
     referenceCollectionUri: zod.z.string().optional(),
 }));
 
+const DataSchema = zod.z.lazy(() => zod.z.object({
+    title: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    type: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+    format: zod.z.string().optional(),
+    properties: zod.z.record(DataSchema).optional(),
+    items: DataSchema.optional(),
+    additionalProperties: zod.z.union([zod.z.boolean(), DataSchema]).optional(),
+    enum: zod.z.array(zod.z.string()).optional(),
+    referenceRecords: zod.z.array(zod.z.any()).optional(),
+    referenceCollection: zod.z
+        .object({
+        key: zod.z.any().optional(),
+        parameters: zod.z.record(zod.z.any()).optional(),
+    })
+        .optional(),
+    referenceUdm: zod.z.string().optional(),
+    default: zod.z.any().optional(),
+    allowCustom: zod.z.boolean().optional(),
+    $ref: zod.z.string().optional(),
+    required: zod.z.array(zod.z.string()).optional(),
+    minLength: zod.z.number().optional(),
+    maxLength: zod.z.number().optional(),
+    minimum: zod.z.number().optional(),
+    maximum: zod.z.number().optional(),
+    maxItems: zod.z.number().optional(),
+    readOnly: zod.z.boolean().optional(),
+    writeOnly: zod.z.boolean().optional(),
+    examples: zod.z.array(zod.z.any()).optional(),
+    anyOf: zod.z.array(DataSchema).optional(),
+    isImplied: zod.z.boolean().optional(),
+    isSensitive: zod.z.boolean().optional(),
+    referenceCollectionPath: zod.z.string().optional(),
+    referenceCollectionUri: zod.z.string().optional(),
+}));
+
 function updateImpliedSchema({ schema: sourceSchema, value, variablesSchema, }) {
     let resultSchema = sourceSchema ? JSON.parse(JSON.stringify(sourceSchema)) : undefined;
     resultSchema = walkSchema(resultSchema, (schema) => (schema.isImplied ? undefined : schema));
@@ -3363,12 +3399,110 @@ function getFormula(value) {
     return undefined;
 }
 
+exports.ConfigurationState = void 0;
+(function (ConfigurationState) {
+    ConfigurationState["CONFIGURED"] = "CONFIGURED";
+    ConfigurationState["NOT_CONFIGURED"] = "NOT_CONFIGURED";
+})(exports.ConfigurationState || (exports.ConfigurationState = {}));
+exports.WorkspaceElementType = void 0;
+(function (WorkspaceElementType) {
+    WorkspaceElementType["Customer"] = "customer";
+    WorkspaceElementType["Connector"] = "connector";
+    WorkspaceElementType["Integration"] = "integration";
+    WorkspaceElementType["Flow"] = "flow";
+    WorkspaceElementType["FlowInstance"] = "flow-instance";
+    WorkspaceElementType["FlowRun"] = "flow-run";
+    WorkspaceElementType["Action"] = "action";
+    WorkspaceElementType["Scenario"] = "scenario";
+    WorkspaceElementType["ActionInstance"] = "action-instance";
+    WorkspaceElementType["Connection"] = "connection";
+    WorkspaceElementType["FieldMapping"] = "field-mapping";
+    WorkspaceElementType["FieldMappingInstance"] = "field-mapping-instance";
+    WorkspaceElementType["DataSource"] = "data-source";
+    WorkspaceElementType["DataSourceInstance"] = "data-source-instance";
+    WorkspaceElementType["DataLinkTable"] = "data-link-table";
+    WorkspaceElementType["DataLinkTableInstance"] = "data-link-table-instance";
+    WorkspaceElementType["AppEventType"] = "app-event-type";
+    WorkspaceElementType["AppEventSubscription"] = "app-event-subscription";
+    WorkspaceElementType["AppDataSchema"] = "app-data-schema";
+    WorkspaceElementType["AppDataSchemaInstance"] = "app-data-schema-instance";
+    WorkspaceElementType["ExternalEventSubscription"] = "external-event-subscription";
+    WorkspaceElementType["ExternalEventLogRecord"] = "external-event-log-record";
+    WorkspaceElementType["ExternalEventPull"] = "external-event-pull";
+    WorkspaceElementType["DataCollection"] = "data-collection";
+    WorkspaceElementType["Screen"] = "screen";
+    WorkspaceElementType["ActionRunLogRecord"] = "action-run-log-record";
+})(exports.WorkspaceElementType || (exports.WorkspaceElementType = {}));
+exports.WorkspaceEventType = void 0;
+(function (WorkspaceEventType) {
+    WorkspaceEventType["ConnectionCreated"] = "connection.created";
+    WorkspaceEventType["ConnectionDeleted"] = "connection.deleted";
+    WorkspaceEventType["ConnectionDisconnected"] = "connection.disconnected";
+    WorkspaceEventType["ConnectionReconnected"] = "connection.reconnected";
+    WorkspaceEventType["FlowRunQueued"] = "flowRun.queued";
+    WorkspaceEventType["FlowRunStarted"] = "flowRun.started";
+    WorkspaceEventType["FlowRunCompleted"] = "flowRun.completed";
+    WorkspaceEventType["FlowRunFailed"] = "flowRun.failed";
+    WorkspaceEventType["FlowRunStopped"] = "flowRun.stopped";
+})(exports.WorkspaceEventType || (exports.WorkspaceEventType = {}));
+exports.WorkspaceElementState = void 0;
+(function (WorkspaceElementState) {
+    WorkspaceElementState["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+    WorkspaceElementState["SETUP_FAILED"] = "SETUP_FAILED";
+    WorkspaceElementState["READY"] = "READY";
+})(exports.WorkspaceElementState || (exports.WorkspaceElementState = {}));
+exports.WorkspaceElementDependencyType = void 0;
+(function (WorkspaceElementDependencyType) {
+    WorkspaceElementDependencyType["Configuration"] = "CONFIGURATION";
+    WorkspaceElementDependencyType["Parent"] = "PARENT";
+})(exports.WorkspaceElementDependencyType || (exports.WorkspaceElementDependencyType = {}));
+const BaseWorkspaceElement = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+});
+const BaseMembraneInterface = BaseWorkspaceElement.extend({
+    key: zod.z.string(),
+    state: zod.z.nativeEnum(exports.WorkspaceElementState).optional(),
+    errors: zod.z.array(ErrorDataSchema).optional(),
+});
+
 exports.FieldMappingDirection = void 0;
 (function (FieldMappingDirection) {
     FieldMappingDirection["IMPORT"] = "import";
     FieldMappingDirection["EXPORT"] = "export";
     FieldMappingDirection["BOTH"] = "both";
 })(exports.FieldMappingDirection || (exports.FieldMappingDirection = {}));
+const BaseFieldMapping = BaseMembraneInterface.extend({
+    revision: zod.z.string(),
+    publishedRevision: zod.z.string().optional(),
+    universalFieldMappingId: zod.z.string().optional(),
+    universalFieldMappingRevision: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    dataSourceId: zod.z.string(),
+    dataSourceKey: zod.z.string(),
+    appSchema: DataSchema,
+    direction: zod.z.nativeEnum(exports.FieldMappingDirection),
+    defaultImportValue: zod.z.any().optional(),
+    defaultExportValue: zod.z.any().optional(),
+    importValue: zod.z.any().optional(),
+    exportValue: zod.z.any().optional(),
+    frozenImportFields: zod.z.any().optional(),
+    frozenExportFields: zod.z.any().optional(),
+    frozenUnifiedExportFields: zod.z.any().optional(),
+    archivedAt: zod.z.string().optional(),
+    customized: zod.z.boolean().optional(),
+});
+const FieldMappingUnitConfig = zod.z.object({
+    key: zod.z.string().optional(),
+    input: zod.z.any().optional(),
+    includeRawFields: zod.z.any().optional(),
+    importValue: zod.z.any().optional(),
+    exportValue: zod.z.any().optional(),
+    default: zod.z.any().optional(),
+    defaultUnifiedValue: zod.z.any().optional(),
+    defaultValue: zod.z.any().optional(),
+    appSchema: DataSchema.optional(),
+});
 
 function mergeWithFormulas(a, b) {
     if (Array.isArray(a) && Array.isArray(b)) {
@@ -3497,6 +3631,56 @@ const ACTIONS = {
     },
 };
 
+const BaseAction = zod.z.object({
+    id: zod.z.string(),
+    key: zod.z.string(),
+    name: zod.z.string(),
+    revision: zod.z.string(),
+    integrationId: zod.z.string().optional(),
+    parentId: zod.z.string().optional(),
+    parentRevision: zod.z.string().optional(),
+    isCustomized: zod.z.boolean().optional(),
+    createdAt: zod.z.string().optional(),
+    updatedAt: zod.z.string().optional(),
+    archivedAt: zod.z.string().optional(),
+    type: zod.z.nativeEnum(exports.ActionType),
+    inputSchema: DataSchema.optional(),
+    config: zod.z.any().optional(),
+    outputMapping: zod.z.any().optional(),
+    customOutputSchema: DataSchema.optional(),
+    defaultOutputSchema: DataSchema.optional(),
+    transformedOutputSchema: DataSchema.optional(),
+    outputSchema: DataSchema.optional(),
+    dependencies: zod.z.array(zod.z.any()).optional(),
+});
+
+const ConnectionRequest = zod.z.object({
+    path: zod.z.any(),
+    method: zod.z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']).optional(),
+    pathParameters: zod.z.record(zod.z.string()).optional(),
+    headers: zod.z.record(zod.z.string()).optional(),
+    query: zod.z.record(zod.z.string()).optional(),
+    data: zod.z.any().optional(),
+});
+const BaseConnection = BaseWorkspaceElement.extend({
+    name: zod.z.string(),
+    userId: zod.z.string(),
+    disconnected: zod.z.boolean().optional(),
+    error: ErrorDataSchema.optional(),
+    integrationId: zod.z.string(),
+    credentials: zod.z.unknown().optional(),
+    parameters: zod.z.unknown().optional(),
+    connectorParameters: zod.z.unknown().optional(),
+    accessToken: zod.z.string().optional(),
+    refreshToken: zod.z.string().optional(),
+    createdAt: zod.z.string(),
+    updatedAt: zod.z.string(),
+    lastActiveAt: zod.z.string().optional(),
+    nextCredentialsRefreshAt: zod.z.string().optional(),
+    archivedAt: zod.z.string().optional(),
+    state: zod.z.nativeEnum(exports.WorkspaceElementState).optional(),
+    errors: zod.z.array(ErrorDataSchema).optional(),
+});
 class ConnectionSpec {
     constructor(opts) {
         Object.assign(this, opts);
@@ -3820,6 +4004,12 @@ exports.ConnectorStatus = void 0;
     ConnectorStatus["beta"] = "beta";
     ConnectorStatus["planned"] = "planned";
 })(exports.ConnectorStatus || (exports.ConnectorStatus = {}));
+const MinimalConnector = zod.z.object({
+    id: zod.z.string(),
+    key: zod.z.string(),
+    name: zod.z.string(),
+    logoUri: zod.z.string(),
+});
 
 const DataRecordSchema = zod.z.object({
     id: zod.z.string(),
@@ -7285,7 +7475,7 @@ function getWritableFieldsSchema(spec) {
     return mergeSchemas([getDataCollectionCreateFields(spec), getDataCollectionUpdateFields(spec)]);
 }
 function getReferenceCollectionPointerForSchema(schema) {
-    if (schema === null || schema === void 0 ? void 0 : schema.referenceCollection) {
+    if ((schema === null || schema === void 0 ? void 0 : schema.referenceCollection) && schema.referenceCollection.key) {
         return schema.referenceCollection;
     }
     else if (schema === null || schema === void 0 ? void 0 : schema.referenceCollectionPath) {
@@ -7880,8 +8070,8 @@ const DataCollectionRecordFromFieldsMethod = {
     getInputSchema: ({ collectionSpec }) => ({
         type: 'object',
         properties: {
-            fields: collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema,
-            parameters: collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.parametersSchema,
+            ...((collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) && { fields: collectionSpec.fieldsSchema }),
+            ...((collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.parametersSchema) && { parameters: collectionSpec.parametersSchema }),
         },
     }),
     getOutputSchema: () => DATA_RECORD_SCHEMA,
@@ -7920,7 +8110,7 @@ const DataCollectionFieldsFromApiMethod = {
             },
         };
     },
-    getOutputSchema: ({ collectionSpec }) => collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema,
+    getOutputSchema: ({ collectionSpec }) => (collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) || { type: 'object' },
     supportedImplementationTypes: [exports.ConnectorMethodImplementationType.javascript],
 };
 const DataCollectionFieldsToApiMethod = {
@@ -7929,7 +8119,7 @@ const DataCollectionFieldsToApiMethod = {
     getInputSchema: ({ collectionSpec }) => ({
         type: 'object',
         properties: {
-            fields: collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema,
+            ...((collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) && { fields: collectionSpec.fieldsSchema }),
         },
     }),
     getOutputSchema: () => {
@@ -7971,134 +8161,134 @@ const DataLocationTypeCollection = {
 };
 const ConnectorDataCollectionMethodKeys = Object.keys(DataLocationTypeCollection.methods);
 
-const ApiRequestSpecSchema = zod.z.object({
+const ApiRequestSpec = zod.z.object({
     path: zod.z.unknown(),
     method: zod.z.unknown(),
 });
-const DataCollectionMethodSpecSchema = zod.z.object({
-    apiRequests: zod.z.array(ApiRequestSpecSchema).optional(),
+const DataCollectionMethodSpec = zod.z.object({
+    apiRequests: zod.z.array(ApiRequestSpec).optional(),
 });
-const DataCollectionListSpecSchema = DataCollectionMethodSpecSchema.extend({
+const DataCollectionListSpec = DataCollectionMethodSpec.extend({
     filterFields: zod.z.array(zod.z.string()).optional(),
 });
-const DataCollectionSearchSpecSchema = DataCollectionMethodSpecSchema.extend({});
-const DataCollectionMatchSpecSchema = DataCollectionMethodSpecSchema.extend({
+const DataCollectionSearchSpec = DataCollectionMethodSpec.extend({});
+const DataCollectionMatchSpec = DataCollectionMethodSpec.extend({
     fields: zod.z.array(zod.z.string()).optional(),
 });
-const DataCollectionFindByIdSpecSchema = DataCollectionMethodSpecSchema.extend({});
-const DataCollectionCreateSpecSchema = DataCollectionMethodSpecSchema.extend({
+const DataCollectionFindByIdSpec = DataCollectionMethodSpec.extend({});
+const DataCollectionCreateSpec = DataCollectionMethodSpec.extend({
     fields: zod.z.array(zod.z.string()).optional(),
     requiredFields: zod.z.array(zod.z.string()).optional(),
     excludedFields: zod.z.array(zod.z.string()).optional(),
 });
-const DataCollectionUpdateSpecSchema = DataCollectionMethodSpecSchema.extend({
+const DataCollectionUpdateSpec = DataCollectionMethodSpec.extend({
     fields: zod.z.array(zod.z.string()).optional(),
     excludedFields: zod.z.array(zod.z.string()).optional(),
 });
-const DataCollectionDeleteSpecSchema = DataCollectionMethodSpecSchema.extend({});
-const DataCollectionFindSpecSchema = DataCollectionMethodSpecSchema.extend({
+const DataCollectionDeleteSpec = DataCollectionMethodSpec.extend({});
+const DataCollectionFindSpec = DataCollectionMethodSpec.extend({
     queryFields: zod.z.array(zod.z.string()).optional(),
 });
-const DataCollectionEventTypeSpecSchema = zod.z.object({
+const DataCollectionEventTypeSpec = zod.z.object({
     type: zod.z.enum(['push', 'pull']),
     isFullScan: zod.z.boolean().optional(),
     isIdOnly: zod.z.boolean().optional(),
 });
-const DataCollectionEventsSpecSchema = zod.z
+const DataCollectionEventsSpec = zod.z
     .object({
-    created: DataCollectionEventTypeSpecSchema.optional(),
-    updated: DataCollectionEventTypeSpecSchema.optional(),
-    deleted: DataCollectionEventTypeSpecSchema.optional(),
-    all: DataCollectionEventTypeSpecSchema.optional(),
+    created: DataCollectionEventTypeSpec.optional(),
+    updated: DataCollectionEventTypeSpec.optional(),
+    deleted: DataCollectionEventTypeSpec.optional(),
+    all: DataCollectionEventTypeSpec.optional(),
 })
-    .catchall(DataCollectionEventTypeSpecSchema);
-const DataCollectionUdmSpecSchema = zod.z.object({
+    .catchall(DataCollectionEventTypeSpec);
+const DataCollectionUdmSpec = zod.z.object({
     fields: zod.z.array(zod.z.string()).optional(),
     extract: zod.z.record(zod.z.any()).optional(),
     parse: zod.z.record(zod.z.any()).optional(),
 });
-const DataCollectionUdmsSpecSchema = zod.z.record(DataCollectionUdmSpecSchema);
-const DataCollectionSpecSchema = zod.z.object({
+const DataCollectionUdmsSpec = zod.z.record(DataCollectionUdmSpec);
+const DataCollectionSpec = zod.z.object({
     type: zod.z.literal('collection'),
     key: zod.z.string().optional(),
     name: zod.z.string(),
-    parametersSchema: DataSchemaSchema.optional(),
-    fieldsSchema: DataSchemaSchema.optional(),
-    list: DataCollectionListSpecSchema.optional(),
-    search: DataCollectionSearchSpecSchema.optional(),
-    match: DataCollectionMatchSpecSchema.optional(),
-    findById: DataCollectionFindByIdSpecSchema.optional(),
-    create: DataCollectionCreateSpecSchema.optional(),
-    update: DataCollectionUpdateSpecSchema.optional(),
-    delete: DataCollectionDeleteSpecSchema.optional(),
-    events: DataCollectionEventsSpecSchema.optional(),
+    parametersSchema: DataSchema.optional(),
+    fieldsSchema: DataSchema.optional(),
+    list: DataCollectionListSpec.optional(),
+    search: DataCollectionSearchSpec.optional(),
+    match: DataCollectionMatchSpec.optional(),
+    findById: DataCollectionFindByIdSpec.optional(),
+    create: DataCollectionCreateSpec.optional(),
+    update: DataCollectionUpdateSpec.optional(),
+    delete: DataCollectionDeleteSpec.optional(),
+    events: DataCollectionEventsSpec.optional(),
     customFields: zod.z.boolean().optional(),
-    udm: DataCollectionUdmsSpecSchema.optional(),
-    find: DataCollectionFindSpecSchema.optional(),
+    udm: DataCollectionUdmsSpec.optional(),
+    find: DataCollectionFindSpec.optional(),
 });
-const DataCollectionMethodRequestSchema = zod.z.object({
+const DataCollectionMethodRequest = zod.z.object({
     parameters: zod.z.record(zod.z.any()).optional(),
 });
-const DataCollectionFindRequestSchema = zod.z.object({
+const DataCollectionFindRequest = zod.z.object({
     query: zod.z.any().optional(),
     cursor: zod.z.string().optional(),
 });
-const DataCollectionFindResponseSchema = zod.z.object({
+const DataCollectionFindResponse = zod.z.object({
     records: zod.z.array(DataRecordSchema),
     cursor: zod.z.string().optional(),
 });
-const DataCollectionListRequestSchema = DataCollectionMethodRequestSchema.extend({
+const DataCollectionListRequest = DataCollectionMethodRequest.extend({
     filter: zod.z.any().optional(),
     unifiedFilter: zod.z.any().optional(),
     cursor: zod.z.string().optional(),
 });
-const DataCollectionListResponseDrilldownSchema = zod.z.object({
+const DataCollectionListResponseDrilldown = zod.z.object({
     parameters: zod.z.record(zod.z.any()).optional(),
     filter: zod.z.record(zod.z.any()).optional(),
 });
-const DataCollectionListResponseSchema = zod.z.object({
+const DataCollectionListResponse = zod.z.object({
     records: zod.z.array(DataRecordSchema),
-    drilldowns: zod.z.array(DataCollectionListResponseDrilldownSchema).optional(),
+    drilldowns: zod.z.array(DataCollectionListResponseDrilldown).optional(),
     cursor: zod.z.string().optional(),
 });
-const DataCollectionSearchRequestSchema = DataCollectionMethodRequestSchema.extend({
+const DataCollectionSearchRequest = DataCollectionMethodRequest.extend({
     query: zod.z.string(),
     cursor: zod.z.string().optional(),
 });
-const DataCollectionSearchResponseSchema = zod.z.object({
+const DataCollectionSearchResponse = zod.z.object({
     records: zod.z.array(DataRecordSchema),
     cursor: zod.z.string().optional(),
 });
-const DataCollectionFindByIdRequestSchema = DataCollectionMethodRequestSchema.extend({
+const DataCollectionFindByIdRequest = DataCollectionMethodRequest.extend({
     id: zod.z.string(),
     udm: zod.z.string().optional(),
 });
-const DataCollectionFindByIdResponseSchema = zod.z.object({
+const DataCollectionFindByIdResponse = zod.z.object({
     record: DataRecordSchema,
 });
-const DataCollectionMatchRequestSchema = DataCollectionMethodRequestSchema.extend({
+const DataCollectionMatchRequest = DataCollectionMethodRequest.extend({
     query: zod.z.record(zod.z.any()),
 });
-const DataCollectionMatchResponseSchema = zod.z.object({
+const DataCollectionMatchResponse = zod.z.object({
     record: DataRecordSchema.optional(),
 });
-const DataCollectionCreateRequestSchema = DataCollectionMethodRequestSchema.extend({
+const DataCollectionCreateRequest = DataCollectionMethodRequest.extend({
     fields: zod.z.record(zod.z.any()),
 });
-const DataCollectionCreateResponseSchema = zod.z.object({
+const DataCollectionCreateResponse = zod.z.object({
     id: zod.z.string(),
 });
-const DataCollectionUpdateRequestSchema = DataCollectionMethodRequestSchema.extend({
+const DataCollectionUpdateRequest = DataCollectionMethodRequest.extend({
     id: zod.z.string(),
     fields: zod.z.record(zod.z.any()),
 });
-const DataCollectionUpdateResponseSchema = zod.z.object({
+const DataCollectionUpdateResponse = zod.z.object({
     id: zod.z.string(),
 });
-const DataCollectionDeleteRequestSchema = DataCollectionMethodRequestSchema.extend({
+const DataCollectionDeleteRequest = DataCollectionMethodRequest.extend({
     id: zod.z.string(),
 });
-const DataCollectionDeleteResponseSchema = zod.z.object({});
+const DataCollectionDeleteResponse = zod.z.object({});
 const ConnectorDataLocationTypes = {
     collection: DataLocationTypeCollection,
 };
@@ -8166,6 +8356,56 @@ const DEFAULT_FULL_SYNC_INTERVAL_SECONDS = 60 * 60 * 3;
 const MIN_FULL_SYNC_INTERVAL_SECONDS = 1 * 60;
 const MIN_PULL_UPDATES_INTERVAL_SECONDS = 1 * 60;
 
+const DataSourceUnitConfig = zod.z.object({
+    key: zod.z.string().optional(),
+    collectionKey: zod.z.any().optional(),
+    collectionParameters: zod.z.any().optional(),
+    udm: zod.z.any().optional(),
+    path: zod.z.string().optional(),
+    pullUpdatesIntervalSeconds: zod.z.number().optional(),
+    fullSyncIntervalSeconds: zod.z.number().optional(),
+});
+const BaseDataSource = BaseMembraneInterface.extend({
+    revision: zod.z.string(),
+    publishedRevision: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    universalDataSourceId: zod.z.string().optional(),
+    universalDataSourceRevision: zod.z.string().optional(),
+    udm: zod.z.string().optional(),
+    pullUpdatesIntervalSeconds: zod.z.number().optional(),
+    fullSyncIntervalSeconds: zod.z.number().optional(),
+    collectionKey: zod.z.string().optional(),
+    collectionParameters: zod.z.any().optional(),
+    archivedAt: zod.z.string().optional(),
+    createdAt: zod.z.string().optional(),
+    updatedAt: zod.z.string().optional(),
+    customized: zod.z.boolean().optional(),
+    defaultPath: zod.z.string().optional(),
+});
+
+const BaseDataSourceInstance = BaseMembraneInterface.extend({
+    userId: zod.z.string(),
+    revision: zod.z.string(),
+    dataSourceRevision: zod.z.string().optional(),
+    dataSourceId: zod.z.string().optional(),
+    universalDataSourceId: zod.z.string().optional(),
+    udm: zod.z.string().optional(),
+    connectionId: zod.z.string(),
+    integrationId: zod.z.string(),
+    instanceKey: zod.z.string().optional(),
+    collectionKey: zod.z.string().optional(),
+    collectionParameters: zod.z.any().optional(),
+    defaultCollectionKey: zod.z.string().optional(),
+    defaultCollectionParameters: zod.z.any().optional(),
+    collectionSpec: DataCollectionSpec.optional(),
+    isCustomized: zod.z.boolean().optional(),
+    errors: zod.z.array(ErrorDataSchema).optional(),
+    pullUpdatesIntervalSeconds: zod.z.number().optional(),
+    fullSyncIntervalSeconds: zod.z.number().optional(),
+    path: zod.z.string().optional(),
+    defaultPath: zod.z.string().optional(),
+});
+
 exports.ExternalEventType = void 0;
 (function (ExternalEventType) {
     ExternalEventType["DataRecordCreated"] = "data-record-created";
@@ -8178,6 +8418,15 @@ exports.IncomingWebhooksState = void 0;
     IncomingWebhooksState["SUCCESS"] = "success";
     IncomingWebhooksState["ERROR"] = "error";
 })(exports.IncomingWebhooksState || (exports.IncomingWebhooksState = {}));
+const ExternalEventUnitConfig = zod.z.object({
+    type: zod.z.nativeEnum(exports.ExternalEventType),
+    dataSource: DataSourceUnitConfig.optional(),
+    eventKey: zod.z.string().optional(),
+    eventParameters: zod.z.any().optional(),
+});
+const BaseExternalEvent = zod.z.object({
+    config: ExternalEventUnitConfig.optional(),
+});
 
 function externalEventTypeToDataCollectionEventType(type) {
     switch (type) {
@@ -8204,6 +8453,23 @@ function dataCollectionEventTypeToExternalEventType(type) {
     }
 }
 
+exports.FlowRunState = void 0;
+(function (FlowRunState) {
+    FlowRunState["QUEUED"] = "queued";
+    FlowRunState["RUNNING"] = "running";
+    FlowRunState["COMPLETED"] = "completed";
+    FlowRunState["STOPPED"] = "stopped";
+    FlowRunState["FAILED"] = "failed";
+})(exports.FlowRunState || (exports.FlowRunState = {}));
+exports.FlowRunLaunchedByTrigger = void 0;
+(function (FlowRunLaunchedByTrigger) {
+    FlowRunLaunchedByTrigger["ApiTrigger"] = "api-trigger";
+    FlowRunLaunchedByTrigger["ScheduleTrigger"] = "schedule-trigger";
+    FlowRunLaunchedByTrigger["AppEventTrigger"] = "app-event-trigger";
+    FlowRunLaunchedByTrigger["DataSourceTrigger"] = "data-source-trigger";
+    FlowRunLaunchedByTrigger["ExternalEvent"] = "external-event";
+})(exports.FlowRunLaunchedByTrigger || (exports.FlowRunLaunchedByTrigger = {}));
+
 exports.FlowRunNodeState = void 0;
 (function (FlowRunNodeState) {
     FlowRunNodeState["RUNNING"] = "running";
@@ -8211,6 +8477,33 @@ exports.FlowRunNodeState = void 0;
     FlowRunNodeState["STOPPED"] = "stopped";
     FlowRunNodeState["FAILED"] = "failed";
 })(exports.FlowRunNodeState || (exports.FlowRunNodeState = {}));
+const FlowRunLaunchedBy = zod.z.object({
+    type: zod.z.nativeEnum(exports.FlowRunLaunchedByTrigger),
+    ids: zod.z.array(zod.z.string()).optional(),
+});
+const FlowRunNode = zod.z.object({
+    state: zod.z.nativeEnum(exports.FlowRunNodeState),
+    runs: zod.z.number().optional(),
+    erroredRuns: zod.z.number().optional(),
+    outputs: zod.z.number().optional(),
+});
+const BaseFlowRun = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string().optional(),
+    flowInstanceId: zod.z.string(),
+    universalFlowId: zod.z.string().optional(),
+    connectionId: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    startNodeKey: zod.z.string(),
+    userId: zod.z.string(),
+    input: zod.z.any().optional(),
+    state: zod.z.nativeEnum(exports.FlowRunState),
+    startTime: zod.z.string(),
+    endTime: zod.z.string().optional(),
+    errors: zod.z.array(ErrorDataSchema).optional(),
+    nodes: zod.z.record(FlowRunNode).optional(),
+    launchedBy: FlowRunLaunchedBy.optional(),
+});
 
 exports.FlowNodeRunStatus = void 0;
 (function (FlowNodeRunStatus) {
@@ -8535,11 +8828,201 @@ const FLOW_NODE_SPECS = {
     [exports.FlowNodeType.RunAction]: RunAction,
 };
 
+const FlowNodeLink = zod.z.object({
+    key: zod.z.string().optional(),
+    filter: zod.z.any().optional(),
+    name: zod.z.string().optional(),
+});
+const FlowNode = zod.z.object({
+    type: zod.z.string().optional(),
+    version: zod.z.number().optional(),
+    name: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    config: zod.z.any().optional(),
+    concurrency: zod.z.number().optional(),
+    onError: zod.z.enum(['stop', 'continue']).optional(),
+    ui: zod.z.any().optional(),
+    inputSchema: zod.z.any().optional(),
+    outputSchema: zod.z.any().optional(),
+    outputExample: zod.z.any().optional(),
+    links: zod.z.array(FlowNodeLink).optional(),
+    isCustomized: zod.z.boolean().optional(),
+});
+const BaseFlow = BaseMembraneInterface.extend({
+    integrationId: zod.z.string().optional(),
+    universalFlowId: zod.z.string().optional(),
+    universalFlowRevision: zod.z.string().optional(),
+    parametersSchema: DataSchema.optional(),
+    nodes: zod.z.record(FlowNode).optional(),
+    autoCreateInstances: zod.z.boolean().optional(),
+    archivedAt: zod.z.string().optional(),
+    revision: zod.z.string(),
+    customized: zod.z.boolean().optional(),
+});
+
+const BaseIntegration = BaseMembraneInterface.extend({
+    logoUri: zod.z.string(),
+    connectorId: zod.z.string().optional(),
+    connectorVersion: zod.z.string().optional(),
+    authOptions: zod.z.array(zod.z.any()).optional(),
+    oAuthCallbackUri: zod.z.string().optional(),
+    parametersSchema: DataSchema.optional(),
+    parameters: zod.z.any().optional(),
+    baseUri: zod.z.string(),
+    archivedAt: zod.z.string().optional(),
+    hasMissingParameters: zod.z.boolean().optional(),
+    hasDocumentation: zod.z.boolean().optional(),
+    hasOperations: zod.z.boolean().optional(),
+    hasData: zod.z.boolean().optional(),
+    hasEvents: zod.z.boolean().optional(),
+    hasGlobalWebhooks: zod.z.boolean().optional(),
+    hasUdm: zod.z.boolean().optional(),
+    isTest: zod.z.boolean().optional(),
+    appUuid: zod.z.string().optional(),
+    isDeactivated: zod.z.boolean().optional(),
+    authType: zod.z.enum(CONNECTOR_AUTH_TYPES).optional(),
+});
+const AppliedToIntegrations = (elementSchema) => zod.z.array(zod.z.object({
+    element: elementSchema,
+    integration: BaseIntegration,
+}));
+
+exports.ScenarioTemplateCategory = void 0;
+(function (ScenarioTemplateCategory) {
+    ScenarioTemplateCategory["DataExport"] = "data-export";
+    ScenarioTemplateCategory["DataImport"] = "data-import";
+    ScenarioTemplateCategory["BiDirectionalSync"] = "bi-directional-sync";
+    ScenarioTemplateCategory["UnifiedApi"] = "unified-api";
+    ScenarioTemplateCategory["DataEnrichment"] = "data-enrichment";
+})(exports.ScenarioTemplateCategory || (exports.ScenarioTemplateCategory = {}));
+const ScenarioToDo = zod.z.object({
+    name: zod.z.string(),
+    description: zod.z.string(),
+    isComplete: zod.z.boolean(),
+});
+const ScenarioElement = zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.string(),
+    element: zod.z.any().optional(),
+});
+const BaseScenario = BaseMembraneInterface.extend({
+    appId: zod.z.string(),
+    scenarioTemplateId: zod.z.string().optional(),
+    elements: zod.z.array(ScenarioElement).optional(),
+    connectors: zod.z.array(MinimalConnector).optional(),
+    todos: zod.z.array(ScenarioToDo).optional(),
+    archivedAt: zod.z.string().optional(),
+});
+const HandyScenarioTemplateElement = zod.z.object({
+    type: zod.z.string(),
+    integration: zod.z.object({ key: zod.z.string(), connectorId: zod.z.string() }).optional(),
+    integrations: zod.z.array(zod.z.object({ key: zod.z.string(), connectorId: zod.z.string() })).optional(),
+    fields: zod.z
+        .object({
+        key: zod.z.string(),
+        name: zod.z.string(),
+    })
+        .and(zod.z.record(zod.z.any())),
+});
+const withIntegrationKeys = (schema) => schema.and(zod.z.object({ integrationKeys: zod.z.array(zod.z.string()).optional() }));
+const ElementsExportFields = zod.z.object({
+    flows: zod.z.record(withIntegrationKeys(zod.z.any())).optional(),
+    actions: zod.z.record(withIntegrationKeys(zod.z.any())).optional(),
+    fieldMappings: zod.z.record(withIntegrationKeys(zod.z.any())).optional(),
+    dataSources: zod.z.record(withIntegrationKeys(zod.z.any())).optional(),
+    dataLinkTables: zod.z.record(zod.z.any()).optional(),
+    appEventTypes: zod.z.record(zod.z.any()).optional(),
+    appDataSchemas: zod.z.record(zod.z.any()).optional(),
+});
+const ScenarioTemplateElements = ElementsExportFields.and(zod.z.object({
+    integrations: zod.z.record(ElementsExportFields.and(zod.z.object({ connectorId: zod.z.string() }))).optional(),
+}));
+const ScenarioTemplate = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    key: zod.z.string(),
+    shortDescription: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    demoWorkspaceKey: zod.z.string().optional(),
+    demoAppUri: zod.z.string().optional(),
+    demoGithubRepo: zod.z.string().optional(),
+    demoVideoYoutubeUri: zod.z.string().optional(),
+    tags: zod.z.array(zod.z.nativeEnum(exports.ScenarioTemplateCategory)).optional(),
+    elements: ScenarioTemplateElements.optional(),
+    todos: zod.z.array(ScenarioToDo.omit({ isComplete: true })).optional(),
+    connectors: zod.z.array(MinimalConnector).optional(),
+    handyElements: zod.z.array(HandyScenarioTemplateElement).optional(),
+});
+
+exports.ScreenType = void 0;
+(function (ScreenType) {
+    ScreenType["Integration"] = "integration";
+})(exports.ScreenType || (exports.ScreenType = {}));
+exports.ScreenBlockType = void 0;
+(function (ScreenBlockType) {
+    ScreenBlockType["Flow"] = "flow";
+    ScreenBlockType["FieldMapping"] = "field-mapping";
+    ScreenBlockType["DataSource"] = "data-source";
+    ScreenBlockType["Action"] = "action";
+})(exports.ScreenBlockType || (exports.ScreenBlockType = {}));
+
+const ScreenBlock = zod.z
+    .object({
+    type: zod.z.nativeEnum(exports.ScreenBlockType),
+})
+    .and(zod.z.record(zod.z.any()));
+const BaseScreen = BaseWorkspaceElement.extend({
+    type: zod.z.nativeEnum(exports.ScreenType),
+    key: zod.z.string().optional(),
+    blocks: zod.z.array(ScreenBlock),
+});
+
+const BaseCustomer = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    internalId: zod.z.string(),
+    fields: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    credentials: zod.z.any().optional(),
+    lastActiveAt: zod.z.string().optional(),
+    isTest: zod.z.boolean().optional(),
+    isBillable: zod.z.boolean().optional(),
+});
+
+const BaseFlowInstance = BaseMembraneInterface.extend({
+    userId: zod.z.string(),
+    connectionId: zod.z.string().optional(),
+    flowId: zod.z.string().optional(),
+    universalFlowId: zod.z.string().optional(),
+    integrationId: zod.z.string(),
+    instanceKey: zod.z.string().optional(),
+    parameters: zod.z.any().optional(),
+    parametersSchema: DataSchema.optional(),
+    nodes: zod.z.record(zod.z.any()).optional(),
+    enabled: zod.z.boolean(),
+    createdAt: zod.z.string(),
+    updatedAt: zod.z.string(),
+    state: zod.z.nativeEnum(exports.WorkspaceElementState).optional(),
+    outdated: zod.z.boolean().optional(),
+    customized: zod.z
+        .object({
+        name: zod.z.boolean().optional(),
+        nodes: zod.z.boolean().optional(),
+    })
+        .optional(),
+    dependencies: zod.z.array(zod.z.any()).optional(),
+});
 exports.FlowInstanceNodeState = void 0;
 (function (FlowInstanceNodeState) {
     FlowInstanceNodeState["SETUP_FAILED"] = "SETUP_FAILED";
     FlowInstanceNodeState["READY"] = "READY";
 })(exports.FlowInstanceNodeState || (exports.FlowInstanceNodeState = {}));
+const FlowInstanceNode = FlowNode.extend({
+    state: zod.z.nativeEnum(exports.FlowInstanceNodeState).optional(),
+    errors: zod.z.array(ErrorDataSchema).optional(),
+    userConfig: zod.z.any().optional(),
+    testInput: zod.z.any().optional(),
+    dependencies: zod.z.array(zod.z.any()).optional(),
+});
 
 const flowNodeLinkSchema = zod.z.object({
     key: zod.z.string().optional(),
@@ -8603,6 +9086,54 @@ exports.ActionDependencyType = void 0;
     ActionDependencyType["FieldMapping"] = "FieldMapping";
     ActionDependencyType["DataSource"] = "DataSource";
 })(exports.ActionDependencyType || (exports.ActionDependencyType = {}));
+const ActionDependency = zod.z.object({
+    type: zod.z.nativeEnum(exports.ActionDependencyType),
+    key: zod.z.string(),
+    element: zod.z.any().optional(),
+});
+const BaseActionInstance = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    revision: zod.z.string(),
+    parentId: zod.z.string().optional(),
+    parentRevision: zod.z.string().optional(),
+    universalParentId: zod.z.string().optional(),
+    userId: zod.z.string(),
+    instanceKey: zod.z.string().optional(),
+    createdAt: zod.z.string().optional(),
+    updatedAt: zod.z.string().optional(),
+    archivedAt: zod.z.string().optional(),
+    type: zod.z.nativeEnum(exports.ActionType),
+    inputSchema: zod.z.any().optional(),
+    config: zod.z.any().optional(),
+    outputSchema: zod.z.any().optional(),
+    isOutdated: zod.z.boolean().optional(),
+    state: zod.z.nativeEnum(exports.WorkspaceElementState),
+});
+
+const BaseFieldMappingInstance = BaseMembraneInterface.extend({
+    userId: zod.z.string(),
+    revision: zod.z.string(),
+    connectionId: zod.z.string(),
+    integrationId: zod.z.string(),
+    fieldMappingRevision: zod.z.string().optional(),
+    fieldMappingId: zod.z.string().optional(),
+    instanceKey: zod.z.string().optional(),
+    dataSourceInstanceId: zod.z.string().optional(),
+    dataSourceSchema: DataSchema.optional(),
+    direction: zod.z.nativeEnum(exports.FieldMappingDirection).optional(),
+    appSchema: DataSchema.optional(),
+    importValue: zod.z.any().optional(),
+    exportValue: zod.z.any().optional(),
+    isCustomized: zod.z.boolean().optional(),
+    unifiedExportValue: zod.z.any().optional(),
+    unifiedImportValue: zod.z.any().optional(),
+    frozenImportFields: zod.z.array(zod.z.string()).optional(),
+    frozenExportFields: zod.z.array(zod.z.string()).optional(),
+    state: zod.z.nativeEnum(exports.WorkspaceElementState).optional(),
+    error: ErrorDataSchema.optional(),
+    externalSchema: zod.z.any().optional(),
+});
 
 exports.DataLinkDirection = void 0;
 (function (DataLinkDirection) {
@@ -8610,6 +9141,106 @@ exports.DataLinkDirection = void 0;
     DataLinkDirection["EXPORT"] = "export";
     DataLinkDirection["BOTH"] = "both";
 })(exports.DataLinkDirection || (exports.DataLinkDirection = {}));
+const BaseDataLinkTable = BaseMembraneInterface.extend({
+    archivedAt: zod.z.string().optional(),
+});
+
+const BaseDataLinkTableInstance = BaseMembraneInterface.extend({
+    dataLinkTableId: zod.z.string().optional(),
+    connectionId: zod.z.string().optional(),
+    integrationId: zod.z.string(),
+    instanceKey: zod.z.string().optional(),
+    userId: zod.z.string(),
+    archivedAt: zod.z.string().optional(),
+});
+const DataLink = zod.z.object({
+    id: zod.z.string(),
+    dataLinkTableInstanceId: zod.z.string(),
+    externalRecordId: zod.z.string(),
+    appRecordId: zod.z.string(),
+    direction: zod.z.nativeEnum(exports.DataLinkDirection),
+});
+const DataLinkTableConfig = zod.z.object({
+    key: zod.z.string(),
+});
+
+exports.HttpRequestMethod = void 0;
+(function (HttpRequestMethod) {
+    HttpRequestMethod["GET"] = "GET";
+    HttpRequestMethod["POST"] = "POST";
+    HttpRequestMethod["PATCH"] = "PATCH";
+    HttpRequestMethod["PUT"] = "PUT";
+    HttpRequestMethod["DELETE"] = "DELETE";
+})(exports.HttpRequestMethod || (exports.HttpRequestMethod = {}));
+const HttpRequestSpec = zod.z.object({
+    method: zod.z.nativeEnum(exports.HttpRequestMethod).optional(),
+    uri: zod.z.any(),
+    headers: zod.z.record(zod.z.any()).optional(),
+    query: zod.z.record(zod.z.any()).optional(),
+    body: zod.z.any().optional(),
+});
+const HTTP_REQUEST_SCHEMA = {
+    type: 'object',
+    properties: {
+        uri: { type: 'string' },
+        method: {
+            type: 'string',
+            enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+        },
+        body: {},
+        query: {
+            type: 'object',
+            section: true,
+            additionalProperties: true,
+        },
+        headers: {
+            type: 'object',
+            section: true,
+            additionalProperties: true,
+        },
+    },
+};
+
+const BaseAppEventType = BaseMembraneInterface.extend({
+    revision: zod.z.string(),
+    archivedAt: zod.z.string().optional(),
+    subscribeRequest: HttpRequestSpec.optional(),
+    example: zod.z.any().optional(),
+    schema: DataSchema.optional(),
+    globalWebhookUri: zod.z.string(),
+    userIdFormula: zod.z.any().optional(),
+});
+
+const BaseAppEventSubscription = BaseMembraneInterface.extend({
+    revision: zod.z.string(),
+    appEventTypeId: zod.z.string(),
+    userId: zod.z.string(),
+    instanceKey: zod.z.string().optional(),
+    isSubscribed: zod.z.boolean(),
+    schema: DataSchema.optional(),
+    webhookUri: zod.z.string(),
+    subscriptionRequest: HttpRequestSpec,
+    subscriptionResponse: zod.z.any().optional(),
+    archivedAt: zod.z.string().optional(),
+});
+
+const BaseAppDataSchema = BaseMembraneInterface.extend({
+    schema: zod.z.any(),
+    code: zod.z.string().optional(),
+    archivedAt: zod.z.string().optional(),
+    revision: zod.z.string().optional(),
+});
+
+const BaseAppDataSchemaInstance = BaseMembraneInterface.extend({
+    appId: zod.z.string(),
+    userId: zod.z.string(),
+    appDataSchemaId: zod.z.string(),
+    appDataSchemaRevision: zod.z.string(),
+    instanceKey: zod.z.string().optional(),
+    schema: zod.z.any().optional(),
+    error: ErrorDataSchema.optional(),
+    archivedAt: zod.z.string().optional(),
+});
 
 exports.ExternalEventSubscriptionStatus = void 0;
 (function (ExternalEventSubscriptionStatus) {
@@ -8624,6 +9255,35 @@ exports.ExternalEventSubscriptionType = void 0;
     ExternalEventSubscriptionType["DataRecordDeleted"] = "data-record-deleted";
     ExternalEventSubscriptionType["ConnectorEvent"] = "connector-event";
 })(exports.ExternalEventSubscriptionType || (exports.ExternalEventSubscriptionType = {}));
+const ExternalEventSubscriptionConfig = zod.z.object({
+    type: zod.z.nativeEnum(exports.ExternalEventSubscriptionType),
+    dataSource: DataSourceUnitConfig.optional(),
+    eventKey: zod.z.string().optional(),
+    eventParameters: zod.z.any().optional(),
+});
+const BaseExternalEventSubscription = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string().optional(),
+    userId: zod.z.string(),
+    connectionId: zod.z.string(),
+    integrationId: zod.z.string(),
+    uuid: zod.z.string(),
+    config: ExternalEventSubscriptionConfig.optional(),
+    status: zod.z.nativeEnum(exports.ExternalEventSubscriptionStatus).optional(),
+    error: ErrorDataSchema.optional(),
+    isRealTime: zod.z.boolean().optional(),
+    requiresPull: zod.z.boolean().optional(),
+    requiresFullSync: zod.z.boolean().optional(),
+    createdAt: zod.z.string().optional(),
+    archivedAt: zod.z.string().optional(),
+    stateData: zod.z.any().optional(),
+    nextPullEventsTimestamp: zod.z.number().optional(),
+    pullUpdatesIntervalSeconds: zod.z.number().optional(),
+    fullSyncIntervalSeconds: zod.z.number().optional(),
+    nextRefreshTimestamp: zod.z.number().optional(),
+    globalWebhookKey: zod.z.string().optional(),
+    globalWebhookEventSelector: zod.z.string().optional(),
+});
 
 exports.ExternalEventLogStatus = void 0;
 (function (ExternalEventLogStatus) {
@@ -8631,143 +9291,667 @@ exports.ExternalEventLogStatus = void 0;
     ExternalEventLogStatus["ERROR"] = "error";
     ExternalEventLogStatus["SUCCESS"] = "success";
 })(exports.ExternalEventLogStatus || (exports.ExternalEventLogStatus = {}));
+const BaseExternalEventLogRecord = zod.z.object({
+    id: zod.z.string(),
+    userId: zod.z.string(),
+    name: zod.z.string().optional(),
+    externalEventSubscriptionId: zod.z.string(),
+    integrationId: zod.z.string(),
+    connectionId: zod.z.string(),
+    payload: zod.z.any().optional(),
+    launchedFlowRunIds: zod.z.array(zod.z.string()).optional(),
+    status: zod.z.nativeEnum(exports.ExternalEventLogStatus),
+    error: ErrorDataSchema.optional(),
+});
+
+exports.ExternalEventPullStatus = void 0;
+(function (ExternalEventPullStatus) {
+    ExternalEventPullStatus["RUNNING"] = "running";
+    ExternalEventPullStatus["SUCCESS"] = "success";
+    ExternalEventPullStatus["ERROR"] = "error";
+    ExternalEventPullStatus["QUEUED"] = "queued";
+})(exports.ExternalEventPullStatus || (exports.ExternalEventPullStatus = {}));
+const BaseExternalEventPull = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string().optional(),
+    userId: zod.z.string(),
+    externalEventSubscriptionId: zod.z.string(),
+    integrationId: zod.z.string(),
+    connectionId: zod.z.string(),
+    startDatetime: zod.z.string(),
+    endDatetime: zod.z.string(),
+    isFullScan: zod.z.boolean().optional(),
+    status: zod.z.nativeEnum(exports.ExternalEventPullStatus),
+    collectedEventIds: zod.z.array(zod.z.string()),
+    error: ErrorDataSchema.optional(),
+});
+
+exports.ActionRunStatus = void 0;
+(function (ActionRunStatus) {
+    ActionRunStatus["RUNNING"] = "running";
+    ActionRunStatus["SUCCESS"] = "success";
+    ActionRunStatus["ERROR"] = "error";
+    ActionRunStatus["QUEUED"] = "queued";
+})(exports.ActionRunStatus || (exports.ActionRunStatus = {}));
+const BaseActionRunLogRecord = zod.z.object({
+    id: zod.z.string(),
+    actionId: zod.z.string(),
+    integrationId: zod.z.string(),
+    connectionId: zod.z.string(),
+    input: zod.z.any().optional(),
+    output: zod.z.any().optional(),
+    status: zod.z.nativeEnum(exports.ActionRunStatus),
+    startedAt: zod.z.string(),
+    completedAt: zod.z.string().optional(),
+    error: ErrorDataSchema.optional(),
+});
+
+const IncludeArchivedQuery = zod.z.object({
+    includeArchived: zod.z.boolean().optional(),
+});
+const SearchQuery = zod.z.object({
+    search: zod.z.string().optional(),
+});
+const PaginationQuery = zod.z.object({
+    limit: zod.z.number().optional(),
+    cursor: zod.z.string().optional(),
+});
+const CommonListElementsQuery = SearchQuery.merge(PaginationQuery).merge(IncludeArchivedQuery);
+const CommonInstancesListQuery = CommonListElementsQuery.extend({
+    userId: zod.z.string().optional(),
+    instanceKey: zod.z.string().optional(),
+});
+const CommonIntegrationOrConnectionQuery = zod.z.object({
+    connectionId: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    integrationKey: zod.z.string().optional(),
+});
+class PaginationResponse {
+}
+
+const ListActionsForIntegrationQuery = zod.z
+    .object({
+    parentId: zod.z.string().optional(),
+})
+    .merge(PaginationQuery);
+const FindActionsQuery = ListActionsForIntegrationQuery.extend({
+    integrationId: zod.z.string().optional(),
+});
+const CreateActionRequest = zod.z.object({
+    key: zod.z.string(),
+    name: zod.z.string(),
+    type: zod.z.nativeEnum(exports.ActionType).optional(),
+    inputSchema: zod.z.any().optional(),
+    config: zod.z.any().optional(),
+    integrationId: zod.z.string().optional(),
+});
+const UpdateActionRequest = zod.z.object({
+    key: zod.z.string().optional(),
+    type: zod.z.nativeEnum(exports.ActionType).optional(),
+    name: zod.z.string().optional(),
+    inputSchema: zod.z.any().optional(),
+    config: zod.z.any().optional(),
+    archivedAt: zod.z.string().optional(),
+});
+const ListActionInstancesForConnectionQuery = zod.z
+    .object({
+    parentId: zod.z.string().optional(),
+    universalParentId: zod.z.string().optional(),
+})
+    .merge(PaginationQuery);
+const FindActionInstancesQuery = ListActionInstancesForConnectionQuery.extend({
+    integrationKey: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    userId: zod.z.string().optional(),
+    connectionId: zod.z.string().optional(),
+});
+const CreateActionInstanceRequest = zod.z.object({
+    parentId: zod.z.string(),
+    connectionId: zod.z.string(),
+    config: zod.z.any().optional(),
+});
+const UpdateActionInstanceRequest = zod.z.object({
+    config: zod.z.any().optional(),
+});
+const ActionRunResponse = zod.z.object({
+    output: zod.z.any().optional(),
+    logs: zod.z.array(zod.z.any()).optional(),
+});
+exports.ActionRunLogStatus = void 0;
+(function (ActionRunLogStatus) {
+    ActionRunLogStatus["SUCCESS"] = "success";
+    ActionRunLogStatus["ERROR"] = "error";
+})(exports.ActionRunLogStatus || (exports.ActionRunLogStatus = {}));
+const Action = BaseAction.extend({
+    integration: BaseIntegration.optional(),
+    appliedToIntegrations: AppliedToIntegrations(BaseAction).optional(),
+});
+
+const FindConnectionsQuery = zod.z
+    .object({
+    userId: zod.z.string().optional(),
+    isTest: zod.z.boolean().optional(),
+    integrationKey: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    includeArchived: zod.z.boolean().optional(),
+})
+    .merge(PaginationQuery);
+const CreateConnectionRequest = zod.z.object({
+    name: zod.z.string(),
+    integrationId: zod.z.string(),
+    credentials: zod.z.string().optional(),
+});
+const UpdateConnectionRequest = zod.z.object({
+    name: zod.z.string().optional(),
+    credentials: zod.z.string().optional(),
+    accessToken: zod.z.string().optional(),
+});
+class FindConnectionsResponse extends PaginationResponse {
+}
+const ConnectionSelector = zod.z.object({
+    id: zod.z.string().optional(),
+    integrationKey: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    connectionId: zod.z.string().optional(),
+});
+const Connection = BaseConnection.extend({
+    user: BaseCustomer.optional(),
+    integration: BaseIntegration.optional(),
+});
+const ConnectionMessagePayload = zod.z.discriminatedUnion('type', [
+    zod.z.object({
+        source: zod.z.string(),
+        requestId: zod.z.string(),
+        type: zod.z.literal('newConnectionCreated'),
+        connection: Connection,
+    }),
+    zod.z.object({
+        source: zod.z.string(),
+        requestId: zod.z.string(),
+        type: zod.z.literal('newConnectionFailure'),
+        error: zod.z.string(),
+        errorData: ErrorDataSchema.optional(),
+    }),
+]);
+
+const ListDataSourcesForIntegrationQuery = zod.z
+    .object({
+    universalDataSourceId: zod.z.string().optional(),
+})
+    .merge(PaginationQuery);
+const FindDataSourcesQuery = ListDataSourcesForIntegrationQuery.extend({
+    integrationId: zod.z.string().optional(),
+});
+const CreateDataSourceRequest = zod.z.object({
+    key: zod.z.string(),
+    name: zod.z.string(),
+    integrationId: zod.z.string().optional(),
+    udm: zod.z.string().optional(),
+    pullUpdatesIntervalSeconds: zod.z.number().optional(),
+    fullSyncIntervalSeconds: zod.z.number().optional(),
+    rootPath: zod.z.string().optional(),
+    defaultPath: zod.z.string().optional(),
+    collectionKey: zod.z.string().optional(),
+    collectionParameters: zod.z.any().optional(),
+});
+const UpdateDataSourceRequest = zod.z.object({
+    key: zod.z.string().optional(),
+    name: zod.z.string().optional(),
+    archivedAt: zod.z.string().optional(),
+    udm: zod.z.string().optional(),
+    pullUpdatesIntervalSeconds: zod.z.number().optional(),
+    fullSyncIntervalSeconds: zod.z.number().optional(),
+    rootPath: zod.z.string().optional(),
+    defaultPath: zod.z.string().optional(),
+});
+const FindDataSourceInstancesQuery = zod.z
+    .object({
+    userId: zod.z.string().optional(),
+    dataSourceId: zod.z.string().optional(),
+    universalDataSourceId: zod.z.string().optional(),
+    connectionId: zod.z.string().optional(),
+    integrationKey: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+})
+    .merge(PaginationQuery);
+const CreateDataSourceInstanceRequest = zod.z.object({
+    dataSourceId: zod.z.string(),
+    connectionId: zod.z.string(),
+    path: zod.z.string().optional(),
+});
+const UpdateDataSourceInstanceRequest = zod.z.object({
+    path: zod.z.string().optional(),
+    collectionKey: zod.z.string().optional(),
+    collectionParameters: zod.z.any().optional(),
+    pullUpdatesIntervalSeconds: zod.z.number().optional(),
+    fullSyncIntervalSeconds: zod.z.number().optional(),
+    subscribedTo: zod.z
+        .object({
+        created: zod.z.boolean().optional(),
+        updated: zod.z.boolean().optional(),
+        deleted: zod.z.boolean().optional(),
+    })
+        .optional(),
+});
+const FindDataSourceEventsQuery = zod.z
+    .object({
+    userId: zod.z.string().optional(),
+    udm: zod.z.string().optional(),
+    dataSourceInstanceId: zod.z.string().optional(),
+    startDatetime: zod.z.string().optional(),
+    endDatetime: zod.z.string().optional(),
+})
+    .merge(PaginationQuery);
+const FindDataSourceSyncsQuery = zod.z
+    .object({
+    userId: zod.z.string().optional(),
+    dataSourceId: zod.z.string().optional(),
+    dataSourceInstanceId: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    connectionId: zod.z.string().optional(),
+    startedAfter: zod.z.string().optional(),
+})
+    .merge(PaginationQuery);
+const ListDataSourceInstancesForConnectionQuery = zod.z
+    .object({
+    dataSourceId: zod.z.string().optional(),
+})
+    .merge(PaginationQuery);
+const FindDataSourceInstanceSyncsQuery = ListDataSourceInstancesForConnectionQuery.extend({
+    userId: zod.z.string().optional(),
+    connectionId: zod.z.string().optional(),
+    integrationId: zod.z.string().optional(),
+    dataSourceInstanceId: zod.z.string().optional(),
+});
+const DataSource = BaseDataSource.extend({
+    integration: BaseIntegration.optional(),
+    appliedToIntegrations: AppliedToIntegrations(BaseDataSource).optional(),
+});
+
+const ExternalEvent = BaseExternalEvent.extend({
+    appliedToIntegrations: AppliedToIntegrations(BaseExternalEvent).optional(),
+});
+
+const ListFlowsForIntegrationQuery = zod.z
+    .object({
+    universalFlowId: zod.z.string().optional(),
+})
+    .merge(CommonListElementsQuery);
+const FindFlowsQuery = ListFlowsForIntegrationQuery.extend({
+    integrationId: zod.z.string().optional(),
+});
+const CreateFlowNodeRequest = zod.z.object({
+    type: zod.z.string(),
+    config: zod.z.any().optional(),
+    ui: zod.z.any().optional(),
+    links: zod.z.array(zod.z.lazy(() => zod.z.any())).optional(),
+});
+const CreateFlowRequest = zod.z.object({
+    key: zod.z.string(),
+    name: zod.z.string(),
+    integrationId: zod.z.string().optional(),
+    nodes: zod.z.record(zod.z.string(), CreateFlowNodeRequest).optional(),
+    parametersSchema: DataSchema.optional(),
+    autoCreateInstances: zod.z.boolean().optional(),
+});
+const UpdateFlowRequest = CreateFlowRequest.extend({
+    archivedAt: zod.z.string().optional(),
+});
+const ListFlowInstancesForConnectionQuery = zod.z
+    .object({
+    flowId: zod.z.string().optional(),
+    flowKey: zod.z.string().optional(),
+    enabled: zod.z.boolean().optional(),
+})
+    .merge(CommonInstancesListQuery);
+const FindFlowInstancesQuery = ListFlowInstancesForConnectionQuery.merge(CommonIntegrationOrConnectionQuery);
+const ResetFlowInstanceOptions = zod.z.object({
+    name: zod.z.boolean().optional(),
+    nodes: zod.z.record(zod.z.string(), zod.z.boolean()).optional(),
+    allNodes: zod.z.boolean().optional(),
+});
+const RunFlowOptions = zod.z.object({
+    nodeKey: zod.z.string().optional(),
+    input: zod.z.any().optional(),
+    returnImmediately: zod.z.boolean().optional(),
+    onUpdate: zod.z.function().optional(),
+});
+const Flow = BaseFlow.extend({
+    integration: BaseIntegration.optional(),
+    appliedToIntegrations: AppliedToIntegrations(BaseFlow).optional(),
+});
+const FlowInstance = BaseFlowInstance.extend({
+    user: zod.z.lazy(() => zod.z.any()).optional(),
+    connection: zod.z.lazy(() => zod.z.any()).optional(),
+    flow: zod.z.lazy(() => Flow).optional(),
+    integration: zod.z.lazy(() => zod.z.any()).optional(),
+});
+
+const POPUP_ELEMENT_ID = '__integration-app-popup';
+const CONTAINER_ELEMENT_ID = '__integration-app-container';
+const CONTAINER_ELEMENT_CLASS = '__integration-app-container';
+const CONTAINER_ELEMENT_CLASS__LOADER = '__integration-app-container__loader';
+const BODY_CLASS = '__integration-app-open';
+const STYLES_ELEMENT_ID = '__integration-app-embed-styles';
+const OpenConfigurationOptions = zod.z.object({
+    onClose: zod.z.function().optional(),
+    showPoweredBy: zod.z.boolean().optional(),
+});
+let IFRAME_START_SHOW_LOADER_TIME = 0;
+let IFRAME_SHOW_LOADER_TIMEOUT_ID;
+const IFRAME_SHOW_LOADER_MINIMAL_TIME = 500;
+const IFRAME_LAYOUT_SHIFT_TIME = 300;
+function showIframeLoader() {
+    const container = getContainer();
+    container === null || container === void 0 ? void 0 : container.classList.add(CONTAINER_ELEMENT_CLASS__LOADER);
+    IFRAME_START_SHOW_LOADER_TIME = Date.now();
+}
+function hideIframeLoader(waitLayoutShift = IFRAME_LAYOUT_SHIFT_TIME) {
+    if (IFRAME_SHOW_LOADER_TIMEOUT_ID) {
+        clearTimeout(IFRAME_SHOW_LOADER_TIMEOUT_ID);
+    }
+    const delta = Date.now() - IFRAME_START_SHOW_LOADER_TIME;
+    if (delta >= IFRAME_SHOW_LOADER_MINIMAL_TIME) {
+        setTimeout(() => {
+            const container = getContainer();
+            container === null || container === void 0 ? void 0 : container.classList.remove(CONTAINER_ELEMENT_CLASS__LOADER);
+            IFRAME_START_SHOW_LOADER_TIME = 0;
+        }, waitLayoutShift);
+        return;
+    }
+    else {
+        const waitLayoutShift = delta >= IFRAME_LAYOUT_SHIFT_TIME ? 0 : IFRAME_LAYOUT_SHIFT_TIME - delta;
+        const timeoutTime = IFRAME_SHOW_LOADER_MINIMAL_TIME - delta;
+        IFRAME_SHOW_LOADER_TIMEOUT_ID = setTimeout(() => {
+            hideIframeLoader(waitLayoutShift);
+        }, timeoutTime);
+        return;
+    }
+}
+async function openIframe(uri, callbacks = {}, { mountTargetSelector } = {}) {
+    close();
+    init(mountTargetSelector);
+    return new Promise((resolve) => {
+        function complete(callback) {
+            close(callback);
+            resolve();
+        }
+        function doOpen() {
+            const iframe = document.createElement('iframe');
+            iframe.src = uri;
+            iframe.id = POPUP_ELEMENT_ID;
+            iframe.onload = () => {
+                hideIframeLoader();
+            };
+            if (!!getContainer()) {
+                document.body.classList.add(BODY_CLASS);
+                showIframeLoader();
+                appendToContainer(iframe);
+                handleIframeUnmount(iframe);
+                penpal.connectToChild({
+                    iframe,
+                    methods: {
+                        ...callbacks,
+                        handshake: (...args) => {
+                            var _a;
+                            hideIframeLoader();
+                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.handshake) === null || _a === void 0 ? void 0 : _a.call(callbacks, ...args);
+                        },
+                        close: () => complete(callbacks.onClose),
+                    },
+                });
+            }
+            else {
+                throw Error('Membrane container element not found. Was it manually removed?');
+            }
+        }
+        if (document.readyState === 'complete' || document.readyState === 'interactive') {
+            doOpen();
+        }
+        else {
+            document.addEventListener('DOMContentLoaded', () => {
+                doOpen();
+            });
+        }
+    });
+}
+function close(callback) {
+    document.body.classList.remove(BODY_CLASS);
+    if (!!getContainer()) {
+        deleteContainer();
+        if (callback) {
+            callback();
+        }
+    }
+}
+function init(mountTargetSelector) {
+    var _a;
+    injectStyles(mountTargetSelector);
+    if (!!getContainer()) {
+        return;
+    }
+    const container = createContainer();
+    if (mountTargetSelector && document.querySelector(mountTargetSelector)) {
+        (_a = document.querySelector(mountTargetSelector)) === null || _a === void 0 ? void 0 : _a.appendChild(container);
+    }
+    else {
+        document.body.appendChild(container);
+    }
+}
+function injectStyles(mountTargetSelector) {
+    const hasCustomMountTarget = Boolean(mountTargetSelector && document.querySelector(mountTargetSelector));
+    const styles = [
+        `.${CONTAINER_ELEMENT_CLASS}:empty {
+      display: none;
+    }`,
+        hasCustomMountTarget
+            ? `.${CONTAINER_ELEMENT_CLASS} {
+        inset: 0;
+        background: rgba(0, 0, 0, 0);
+        transition: background 0.2s ease-out;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        width: 100%;
+        height: 100%;
+      }`
+            : `.${CONTAINER_ELEMENT_CLASS} {
+        position: fixed;
+        inset: 0;
+        z-index: 2147483647;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        pointer-events: auto;
+        background: rgba(0, 0, 0, 0);
+        transition: background 0.2s ease-out;
+      }`,
+        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} {
+      background: rgba(0, 0, 0, 0.8);
+    }`,
+        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER}::before {
+      ${hasCustomMountTarget ? 'position: absolute;' : ''}
+      content: "";
+      width: 5rem;
+      height: 4rem;
+      background-image: url('data:image/svg+xml,%3Csvg viewBox="0 0 32 22" fill="%23000" xmlns="http://www.w3.org/2000/svg" %3E%3Cdefs%3E%3Cmask id="a"%3E%3Crect width="100%25" height="100%25" fill="%23fff" /%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/mask%3E%3Cmask id="b"%3E%3Crect width="100%25" height="100%25" fill="%23fff"/%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z" %3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/mask%3E%3C/defs%3E%3Cg mask="url(%23a)"%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z"%0A%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/g%3E%3Cg mask="url(%23b)"%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/g%3E%3C/svg%3E');
+      background-size: contain;
+      background-repeat: no-repeat;
+      background-position: center;
+      filter: invert(1);
+    }`,
+        `.${CONTAINER_ELEMENT_CLASS} iframe {
+      ${hasCustomMountTarget ? '' : 'position: absolute;'}
+      width: 100%;
+      height: 100%;
+      border-width: 0;
+
+      /* fix transparent bg, because iframe document has light scheme */
+      color-scheme: light;
+    }`,
+        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} iframe {
+      visibility: hidden;
+    }`,
+        !hasCustomMountTarget
+            ? `body.${BODY_CLASS} {
+          overflow: hidden;
+        }`
+            : '',
+    ];
+    let styleElement = document.getElementById(STYLES_ELEMENT_ID);
+    if (!styleElement) {
+        styleElement = document.createElement('style');
+        styleElement.id = STYLES_ELEMENT_ID;
+        styleElement.type = 'text/css';
+        document.head.appendChild(styleElement);
+    }
+    styleElement.textContent = styles.join('\n');
+}
+function removeInjectedStyles() {
+    const stylesElement = document.getElementById(STYLES_ELEMENT_ID);
+    if (stylesElement) {
+        stylesElement.remove();
+    }
+}
+function createContainer() {
+    const container = document.createElement('div');
+    container.id = CONTAINER_ELEMENT_ID;
+    container.classList.add(CONTAINER_ELEMENT_CLASS);
+    return container;
+}
+function getContainer() {
+    return document.getElementById(CONTAINER_ELEMENT_ID);
+}
+function appendToContainer(el) {
+    const container = getContainer();
+    container === null || container === void 0 ? void 0 : container.appendChild(el);
+}
+function deleteContainer() {
+    const container = getContainer();
+    if (container) {
+        container.remove();
+    }
+    removeInjectedStyles();
+}
+function handleIframeUnmount(iframe) {
+    const observer = new MutationObserver((mutationsList) => {
+        for (const mutation of mutationsList) {
+            for (const removedNode of mutation.removedNodes) {
+                if (removedNode instanceof HTMLElement && removedNode.id === POPUP_ELEMENT_ID) {
+                    observer.disconnect();
+                    deleteContainer();
+                    return;
+                }
+            }
+        }
+    });
+    const parent = iframe.parentNode;
+    if (parent) {
+        observer.observe(parent, {
+            childList: true,
+        });
+    }
+    else {
+        console.warn(`iframe with ID "${POPUP_ELEMENT_ID}" has no parent node`);
+    }
+}
 
-exports.ExternalEventPullStatus = void 0;
-(function (ExternalEventPullStatus) {
-    ExternalEventPullStatus["RUNNING"] = "running";
-    ExternalEventPullStatus["SUCCESS"] = "success";
-    ExternalEventPullStatus["ERROR"] = "error";
-    ExternalEventPullStatus["QUEUED"] = "queued";
-})(exports.ExternalEventPullStatus || (exports.ExternalEventPullStatus = {}));
+const CreateIntegrationRequest = zod.z.object({
+    name: zod.z.string().optional(),
+    key: zod.z.string(),
+    baseUri: zod.z.string(),
+    logoUri: zod.z.string(),
+});
+const UpdateIntegrationRequest = zod.z.object({
+    name: zod.z.string().optional(),
+    key: zod.z.string().optional(),
+    baseUri: zod.z.string().optional(),
+    logoUri: zod.z.string().optional(),
+});
+const FindIntegrationsQuery = zod.z.object({}).merge(PaginationQuery).merge(SearchQuery);
+const OpenNewConnectionOptions = zod.z
+    .object({
+    allowMultipleConnections: zod.z.boolean().optional(),
+    name: zod.z.string().optional(),
+    connectorParameters: zod.z.any().optional(),
+})
+    .merge(OpenConfigurationOptions);
+const Integration = BaseIntegration.extend({
+    connection: BaseConnection.optional(),
+    spec: zod.z.any().optional(),
+});
 
-exports.ActionRunStatus = void 0;
-(function (ActionRunStatus) {
-    ActionRunStatus["RUNNING"] = "running";
-    ActionRunStatus["SUCCESS"] = "success";
-    ActionRunStatus["ERROR"] = "error";
-    ActionRunStatus["QUEUED"] = "queued";
-})(exports.ActionRunStatus || (exports.ActionRunStatus = {}));
+exports.IntegrationElementLevel = void 0;
+(function (IntegrationElementLevel) {
+    IntegrationElementLevel["UNIVERSAL"] = "universal";
+    IntegrationElementLevel["CONNECTOR"] = "connector";
+    IntegrationElementLevel["CONNECTION"] = "connection";
+})(exports.IntegrationElementLevel || (exports.IntegrationElementLevel = {}));
+exports.IntegrationElementType = void 0;
+(function (IntegrationElementType) {
+    IntegrationElementType["APP_DATA_SCHEMA"] = "app-data-schema";
+    IntegrationElementType["APP_EVENT_TYPE"] = "app-event-type";
+    IntegrationElementType["DATA_SOURCE"] = "data-source";
+    IntegrationElementType["SCHEMA"] = "schema";
+    IntegrationElementType["FIELD_MAPPING"] = "field-mapping";
+    IntegrationElementType["FLOW"] = "flow";
+    IntegrationElementType["INTEGRATION"] = "integration";
+    IntegrationElementType["ACTION"] = "action";
+    IntegrationElementType["DATA_LINK_TABLE"] = "data-link-table";
+    IntegrationElementType["EXTERNAL_EVENT"] = "external-event";
+})(exports.IntegrationElementType || (exports.IntegrationElementType = {}));
 
-exports.ConfigurationState = void 0;
-(function (ConfigurationState) {
-    ConfigurationState["CONFIGURED"] = "CONFIGURED";
-    ConfigurationState["NOT_CONFIGURED"] = "NOT_CONFIGURED";
-})(exports.ConfigurationState || (exports.ConfigurationState = {}));
-exports.WorkspaceElementType = void 0;
-(function (WorkspaceElementType) {
-    WorkspaceElementType["Customer"] = "customer";
-    WorkspaceElementType["Connector"] = "connector";
-    WorkspaceElementType["Integration"] = "integration";
-    WorkspaceElementType["Flow"] = "flow";
-    WorkspaceElementType["FlowInstance"] = "flow-instance";
-    WorkspaceElementType["FlowRun"] = "flow-run";
-    WorkspaceElementType["Action"] = "action";
-    WorkspaceElementType["Scenario"] = "scenario";
-    WorkspaceElementType["ActionInstance"] = "action-instance";
-    WorkspaceElementType["Connection"] = "connection";
-    WorkspaceElementType["FieldMapping"] = "field-mapping";
-    WorkspaceElementType["FieldMappingInstance"] = "field-mapping-instance";
-    WorkspaceElementType["DataSource"] = "data-source";
-    WorkspaceElementType["DataSourceInstance"] = "data-source-instance";
-    WorkspaceElementType["DataLinkTable"] = "data-link-table";
-    WorkspaceElementType["DataLinkTableInstance"] = "data-link-table-instance";
-    WorkspaceElementType["AppEventType"] = "app-event-type";
-    WorkspaceElementType["AppEventSubscription"] = "app-event-subscription";
-    WorkspaceElementType["AppDataSchema"] = "app-data-schema";
-    WorkspaceElementType["AppDataSchemaInstance"] = "app-data-schema-instance";
-    WorkspaceElementType["ExternalEventSubscription"] = "external-event-subscription";
-    WorkspaceElementType["ExternalEventLogRecord"] = "external-event-log-record";
-    WorkspaceElementType["ExternalEventPull"] = "external-event-pull";
-    WorkspaceElementType["DataCollection"] = "data-collection";
-    WorkspaceElementType["Screen"] = "screen";
-    WorkspaceElementType["ActionRunLogRecord"] = "action-run-log-record";
-})(exports.WorkspaceElementType || (exports.WorkspaceElementType = {}));
-exports.WorkspaceEventType = void 0;
-(function (WorkspaceEventType) {
-    WorkspaceEventType["ConnectionCreated"] = "connection.created";
-    WorkspaceEventType["ConnectionDeleted"] = "connection.deleted";
-    WorkspaceEventType["ConnectionDisconnected"] = "connection.disconnected";
-    WorkspaceEventType["ConnectionReconnected"] = "connection.reconnected";
-    WorkspaceEventType["FlowRunQueued"] = "flowRun.queued";
-    WorkspaceEventType["FlowRunStarted"] = "flowRun.started";
-    WorkspaceEventType["FlowRunCompleted"] = "flowRun.completed";
-    WorkspaceEventType["FlowRunFailed"] = "flowRun.failed";
-    WorkspaceEventType["FlowRunStopped"] = "flowRun.stopped";
-})(exports.WorkspaceEventType || (exports.WorkspaceEventType = {}));
-exports.WorkspaceElementState = void 0;
-(function (WorkspaceElementState) {
-    WorkspaceElementState["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
-    WorkspaceElementState["SETUP_FAILED"] = "SETUP_FAILED";
-    WorkspaceElementState["READY"] = "READY";
-})(exports.WorkspaceElementState || (exports.WorkspaceElementState = {}));
-exports.WorkspaceElementDependencyType = void 0;
-(function (WorkspaceElementDependencyType) {
-    WorkspaceElementDependencyType["Configuration"] = "CONFIGURATION";
-    WorkspaceElementDependencyType["Parent"] = "PARENT";
-})(exports.WorkspaceElementDependencyType || (exports.WorkspaceElementDependencyType = {}));
-const BaseWorkspaceElement = zod.z.object({
-    id: zod.z.string(),
+const ScenarioToDoApi = zod.z.object({
     name: zod.z.string(),
+    description: zod.z.string(),
+    isComplete: zod.z.boolean(),
 });
-const BaseMembraneInterface = BaseWorkspaceElement.extend({
+const ScenarioElementApi = zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.nativeEnum(exports.IntegrationElementType),
+    element: zod.z.any().optional(),
+});
+const FindScenariosQuery = zod.z.object({}).merge(SearchQuery).merge(PaginationQuery);
+const CreateScenarioRequest = zod.z.object({
+    name: zod.z.string(),
     key: zod.z.string(),
-    state: zod.z.nativeEnum(exports.WorkspaceElementState).optional(),
-    errors: zod.z.array(ErrorDataSchema).optional(),
+    elements: zod.z.array(ScenarioElementApi).optional(),
+    todos: zod.z.array(ScenarioToDoApi).optional(),
+});
+const UpdateScenarioRequest = zod.z.object({
+    name: zod.z.string().optional(),
+    key: zod.z.string().optional(),
+    elements: zod.z.array(ScenarioElementApi).optional(),
+    todos: zod.z.array(ScenarioToDoApi).optional(),
+});
+const Scenario = BaseScenario.extend({
+    appliedToIntegrations: zod.z.array(BaseIntegration).optional(),
 });
 
-exports.ActionRunLogStatus = void 0;
-(function (ActionRunLogStatus) {
-    ActionRunLogStatus["SUCCESS"] = "success";
-    ActionRunLogStatus["ERROR"] = "error";
-})(exports.ActionRunLogStatus || (exports.ActionRunLogStatus = {}));
-
-class PaginationResponse {
-}
-
-class CreateConnectionRequest {
-}
-class UpdateConnectionRequest {
-}
-class FindConnectionsResponse extends PaginationResponse {
-}
-
-exports.FlowRunState = void 0;
-(function (FlowRunState) {
-    FlowRunState["QUEUED"] = "queued";
-    FlowRunState["RUNNING"] = "running";
-    FlowRunState["COMPLETED"] = "completed";
-    FlowRunState["STOPPED"] = "stopped";
-    FlowRunState["FAILED"] = "failed";
-})(exports.FlowRunState || (exports.FlowRunState = {}));
-exports.FlowRunLaunchedByTrigger = void 0;
-(function (FlowRunLaunchedByTrigger) {
-    FlowRunLaunchedByTrigger["ApiTrigger"] = "api-trigger";
-    FlowRunLaunchedByTrigger["ScheduleTrigger"] = "schedule-trigger";
-    FlowRunLaunchedByTrigger["AppEventTrigger"] = "app-event-trigger";
-    FlowRunLaunchedByTrigger["DataSourceTrigger"] = "data-source-trigger";
-    FlowRunLaunchedByTrigger["ExternalEvent"] = "external-event";
-})(exports.FlowRunLaunchedByTrigger || (exports.FlowRunLaunchedByTrigger = {}));
-
-exports.ScenarioTemplateCategory = void 0;
-(function (ScenarioTemplateCategory) {
-    ScenarioTemplateCategory["DataExport"] = "data-export";
-    ScenarioTemplateCategory["DataImport"] = "data-import";
-    ScenarioTemplateCategory["BiDirectionalSync"] = "bi-directional-sync";
-    ScenarioTemplateCategory["UnifiedApi"] = "unified-api";
-    ScenarioTemplateCategory["DataEnrichment"] = "data-enrichment";
-})(exports.ScenarioTemplateCategory || (exports.ScenarioTemplateCategory = {}));
+const CreateCustomerRequest = zod.z.object({
+    name: zod.z.string().optional(),
+    internalId: zod.z.string(),
+    fields: zod.z.any().optional(),
+    credentials: zod.z.any().optional(),
+});
+const UpdateCustomerRequest = zod.z.object({
+    name: zod.z.string().optional(),
+    internalId: zod.z.string().optional(),
+    fields: zod.z.any().optional(),
+    credentials: zod.z.any().optional(),
+});
+const FindCustomersQuery = zod.z
+    .object({
+    isTest: zod.z.boolean().optional(),
+})
+    .merge(PaginationQuery)
+    .merge(SearchQuery);
+const CustomerSelector = zod.z.object({ id: zod.z.string() });
 
-exports.ScreenType = void 0;
-(function (ScreenType) {
-    ScreenType["Integration"] = "integration";
-})(exports.ScreenType || (exports.ScreenType = {}));
-exports.ScreenBlockType = void 0;
-(function (ScreenBlockType) {
-    ScreenBlockType["Flow"] = "flow";
-    ScreenBlockType["FieldMapping"] = "field-mapping";
-    ScreenBlockType["DataSource"] = "data-source";
-    ScreenBlockType["Action"] = "action";
-})(exports.ScreenBlockType || (exports.ScreenBlockType = {}));
+const FieldMapping = BaseFieldMapping.extend({
+    integration: BaseIntegration.optional(),
+    appliedToIntegrations: AppliedToIntegrations(BaseFieldMapping).optional(),
+});
 
 class DependencyError extends IntegrationAppError {
     constructor(arg, workspaceElementReference) {
@@ -8840,7 +10024,7 @@ function getChildNodeKeys(flow, nodeKey) {
     return (nodeLinks
         .map((nodeLink) => nodeLink.key)
         .filter(Boolean)
-        .filter((k) => { var _a; return !!((_a = flow.nodes) === null || _a === void 0 ? void 0 : _a[k]); }));
+        .filter((k) => { var _a; return k && !!((_a = flow.nodes) === null || _a === void 0 ? void 0 : _a[k]); }));
 }
 function getDownstreamNodeKeys(flow, nodeKey) {
     const linkedKeys = getChildNodeKeys(flow, nodeKey);
@@ -9413,83 +10597,33 @@ class DataForm {
 
 function parseDate(value) {
     let timestamp;
-    if (typeof value === 'number') {
-        timestamp = value;
-    }
-    else if (typeof value === 'string') {
-        timestamp = Date.parse(value);
-        if (isNaN(timestamp)) {
-            timestamp = undefined;
-        }
-        if (!timestamp && Number(value) > 1000000000) {
-            timestamp = Number(value);
-        }
-    }
-    if (timestamp) {
-        return timestampToDate(timestamp);
-    }
-    else {
-        return undefined;
-    }
-}
-function timestampToDate(value) {
-    if (Math.round(value).toString().length < 13) {
-        return new Date(value * 1000);
-    }
-    else {
-        return new Date(value);
-    }
-}
-
-exports.HttpRequestMethod = void 0;
-(function (HttpRequestMethod) {
-    HttpRequestMethod["GET"] = "GET";
-    HttpRequestMethod["POST"] = "POST";
-    HttpRequestMethod["PATCH"] = "PATCH";
-    HttpRequestMethod["PUT"] = "PUT";
-    HttpRequestMethod["DELETE"] = "DELETE";
-})(exports.HttpRequestMethod || (exports.HttpRequestMethod = {}));
-const HTTP_REQUEST_SCHEMA = {
-    type: 'object',
-    properties: {
-        uri: { type: 'string' },
-        method: {
-            type: 'string',
-            enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
-        },
-        body: {},
-        query: {
-            type: 'object',
-            section: true,
-            additionalProperties: true,
-        },
-        headers: {
-            type: 'object',
-            section: true,
-            additionalProperties: true,
-        },
-    },
-};
-
-exports.IntegrationElementLevel = void 0;
-(function (IntegrationElementLevel) {
-    IntegrationElementLevel["UNIVERSAL"] = "universal";
-    IntegrationElementLevel["CONNECTOR"] = "connector";
-    IntegrationElementLevel["CONNECTION"] = "connection";
-})(exports.IntegrationElementLevel || (exports.IntegrationElementLevel = {}));
-exports.IntegrationElementType = void 0;
-(function (IntegrationElementType) {
-    IntegrationElementType["APP_DATA_SCHEMA"] = "app-data-schema";
-    IntegrationElementType["APP_EVENT_TYPE"] = "app-event-type";
-    IntegrationElementType["DATA_SOURCE"] = "data-source";
-    IntegrationElementType["SCHEMA"] = "schema";
-    IntegrationElementType["FIELD_MAPPING"] = "field-mapping";
-    IntegrationElementType["FLOW"] = "flow";
-    IntegrationElementType["INTEGRATION"] = "integration";
-    IntegrationElementType["ACTION"] = "action";
-    IntegrationElementType["DATA_LINK_TABLE"] = "data-link-table";
-    IntegrationElementType["EXTERNAL_EVENT"] = "external-event";
-})(exports.IntegrationElementType || (exports.IntegrationElementType = {}));
+    if (typeof value === 'number') {
+        timestamp = value;
+    }
+    else if (typeof value === 'string') {
+        timestamp = Date.parse(value);
+        if (isNaN(timestamp)) {
+            timestamp = undefined;
+        }
+        if (!timestamp && Number(value) > 1000000000) {
+            timestamp = Number(value);
+        }
+    }
+    if (timestamp) {
+        return timestampToDate(timestamp);
+    }
+    else {
+        return undefined;
+    }
+}
+function timestampToDate(value) {
+    if (Math.round(value).toString().length < 13) {
+        return new Date(value * 1000);
+    }
+    else {
+        return new Date(value);
+    }
+}
 
 exports.UsageType = void 0;
 (function (UsageType) {
@@ -9926,231 +11060,6 @@ class IntegrationLevelActionsListAccessor extends IntegrationLevelElementsListAc
     }
 }
 
-const POPUP_ELEMENT_ID = '__integration-app-popup';
-const CONTAINER_ELEMENT_ID = '__integration-app-container';
-const CONTAINER_ELEMENT_CLASS = '__integration-app-container';
-const CONTAINER_ELEMENT_CLASS__LOADER = '__integration-app-container__loader';
-const BODY_CLASS = '__integration-app-open';
-const STYLES_ELEMENT_ID = '__integration-app-embed-styles';
-let IFRAME_START_SHOW_LOADER_TIME = 0;
-let IFRAME_SHOW_LOADER_TIMEOUT_ID;
-const IFRAME_SHOW_LOADER_MINIMAL_TIME = 500;
-const IFRAME_LAYOUT_SHIFT_TIME = 300;
-function showIframeLoader() {
-    const container = getContainer();
-    container === null || container === void 0 ? void 0 : container.classList.add(CONTAINER_ELEMENT_CLASS__LOADER);
-    IFRAME_START_SHOW_LOADER_TIME = Date.now();
-}
-function hideIframeLoader(waitLayoutShift = IFRAME_LAYOUT_SHIFT_TIME) {
-    if (IFRAME_SHOW_LOADER_TIMEOUT_ID) {
-        clearTimeout(IFRAME_SHOW_LOADER_TIMEOUT_ID);
-    }
-    const delta = Date.now() - IFRAME_START_SHOW_LOADER_TIME;
-    if (delta >= IFRAME_SHOW_LOADER_MINIMAL_TIME) {
-        setTimeout(() => {
-            const container = getContainer();
-            container === null || container === void 0 ? void 0 : container.classList.remove(CONTAINER_ELEMENT_CLASS__LOADER);
-            IFRAME_START_SHOW_LOADER_TIME = 0;
-        }, waitLayoutShift);
-        return;
-    }
-    else {
-        const waitLayoutShift = delta >= IFRAME_LAYOUT_SHIFT_TIME ? 0 : IFRAME_LAYOUT_SHIFT_TIME - delta;
-        const timeoutTime = IFRAME_SHOW_LOADER_MINIMAL_TIME - delta;
-        IFRAME_SHOW_LOADER_TIMEOUT_ID = setTimeout(() => {
-            hideIframeLoader(waitLayoutShift);
-        }, timeoutTime);
-        return;
-    }
-}
-async function openIframe(uri, callbacks = {}, { mountTargetSelector } = {}) {
-    close();
-    init(mountTargetSelector);
-    return new Promise((resolve) => {
-        function complete(callback) {
-            close(callback);
-            resolve();
-        }
-        function doOpen() {
-            const iframe = document.createElement('iframe');
-            iframe.src = uri;
-            iframe.id = POPUP_ELEMENT_ID;
-            iframe.onload = () => {
-                hideIframeLoader();
-            };
-            if (!!getContainer()) {
-                document.body.classList.add(BODY_CLASS);
-                showIframeLoader();
-                appendToContainer(iframe);
-                handleIframeUnmount(iframe);
-                penpal.connectToChild({
-                    iframe,
-                    methods: {
-                        ...callbacks,
-                        handshake: (...args) => {
-                            var _a;
-                            hideIframeLoader();
-                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.handshake) === null || _a === void 0 ? void 0 : _a.call(callbacks, ...args);
-                        },
-                        close: () => complete(callbacks.onClose),
-                    },
-                });
-            }
-            else {
-                throw Error('Membrane container element not found. Was it manually removed?');
-            }
-        }
-        if (document.readyState === 'complete' || document.readyState === 'interactive') {
-            doOpen();
-        }
-        else {
-            document.addEventListener('DOMContentLoaded', () => {
-                doOpen();
-            });
-        }
-    });
-}
-function close(callback) {
-    document.body.classList.remove(BODY_CLASS);
-    if (!!getContainer()) {
-        deleteContainer();
-        if (callback) {
-            callback();
-        }
-    }
-}
-function init(mountTargetSelector) {
-    var _a;
-    injectStyles(mountTargetSelector);
-    if (!!getContainer()) {
-        return;
-    }
-    const container = createContainer();
-    if (mountTargetSelector && document.querySelector(mountTargetSelector)) {
-        (_a = document.querySelector(mountTargetSelector)) === null || _a === void 0 ? void 0 : _a.appendChild(container);
-    }
-    else {
-        document.body.appendChild(container);
-    }
-}
-function injectStyles(mountTargetSelector) {
-    const hasCustomMountTarget = Boolean(mountTargetSelector && document.querySelector(mountTargetSelector));
-    const styles = [
-        `.${CONTAINER_ELEMENT_CLASS}:empty {
-      display: none;
-    }`,
-        hasCustomMountTarget
-            ? `.${CONTAINER_ELEMENT_CLASS} {
-        inset: 0;
-        background: rgba(0, 0, 0, 0);
-        transition: background 0.2s ease-out;
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        width: 100%;
-        height: 100%;
-      }`
-            : `.${CONTAINER_ELEMENT_CLASS} {
-        position: fixed;
-        inset: 0;
-        z-index: 2147483647;
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        pointer-events: auto;
-        background: rgba(0, 0, 0, 0);
-        transition: background 0.2s ease-out;
-      }`,
-        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} {
-      background: rgba(0, 0, 0, 0.8);
-    }`,
-        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER}::before {
-      ${hasCustomMountTarget ? 'position: absolute;' : ''}
-      content: "";
-      width: 5rem;
-      height: 4rem;
-      background-image: url('data:image/svg+xml,%3Csvg viewBox="0 0 32 22" fill="%23000" xmlns="http://www.w3.org/2000/svg" %3E%3Cdefs%3E%3Cmask id="a"%3E%3Crect width="100%25" height="100%25" fill="%23fff" /%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/mask%3E%3Cmask id="b"%3E%3Crect width="100%25" height="100%25" fill="%23fff"/%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z" %3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/mask%3E%3C/defs%3E%3Cg mask="url(%23a)"%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z"%0A%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/g%3E%3Cg mask="url(%23b)"%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/g%3E%3C/svg%3E');
-      background-size: contain;
-      background-repeat: no-repeat;
-      background-position: center;
-      filter: invert(1);
-    }`,
-        `.${CONTAINER_ELEMENT_CLASS} iframe {
-      ${hasCustomMountTarget ? '' : 'position: absolute;'}
-      width: 100%;
-      height: 100%;
-      border-width: 0;
-
-      /* fix transparent bg, because iframe document has light scheme */
-      color-scheme: light;
-    }`,
-        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} iframe {
-      visibility: hidden;
-    }`,
-        !hasCustomMountTarget
-            ? `body.${BODY_CLASS} {
-          overflow: hidden;
-        }`
-            : '',
-    ];
-    let styleElement = document.getElementById(STYLES_ELEMENT_ID);
-    if (!styleElement) {
-        styleElement = document.createElement('style');
-        styleElement.id = STYLES_ELEMENT_ID;
-        styleElement.type = 'text/css';
-        document.head.appendChild(styleElement);
-    }
-    styleElement.textContent = styles.join('\n');
-}
-function removeInjectedStyles() {
-    const stylesElement = document.getElementById(STYLES_ELEMENT_ID);
-    if (stylesElement) {
-        stylesElement.remove();
-    }
-}
-function createContainer() {
-    const container = document.createElement('div');
-    container.id = CONTAINER_ELEMENT_ID;
-    container.classList.add(CONTAINER_ELEMENT_CLASS);
-    return container;
-}
-function getContainer() {
-    return document.getElementById(CONTAINER_ELEMENT_ID);
-}
-function appendToContainer(el) {
-    const container = getContainer();
-    container === null || container === void 0 ? void 0 : container.appendChild(el);
-}
-function deleteContainer() {
-    const container = getContainer();
-    if (container) {
-        container.remove();
-    }
-    removeInjectedStyles();
-}
-function handleIframeUnmount(iframe) {
-    const observer = new MutationObserver((mutationsList) => {
-        for (const mutation of mutationsList) {
-            for (const removedNode of mutation.removedNodes) {
-                if (removedNode instanceof HTMLElement && removedNode.id === POPUP_ELEMENT_ID) {
-                    observer.disconnect();
-                    deleteContainer();
-                    return;
-                }
-            }
-        }
-    });
-    const parent = iframe.parentNode;
-    if (parent) {
-        observer.observe(parent, {
-            childList: true,
-        });
-    }
-    else {
-        console.warn(`iframe with ID "${POPUP_ELEMENT_ID}" has no parent node`);
-    }
-}
-
 class ConnectionLevelElementAccessor {
     constructor(client, connectionSelector, selector, elementKey, query) {
         this.client = client;
@@ -11372,6 +12281,11 @@ class ExternalEventSubscriptionAccessor {
     }
 }
 
+exports.WorkspaceSyncEventType = void 0;
+(function (WorkspaceSyncEventType) {
+    WorkspaceSyncEventType["ElementUpdate"] = "element-update";
+})(exports.WorkspaceSyncEventType || (exports.WorkspaceSyncEventType = {}));
+
 function decodeJWT(token) {
     if (typeof token !== 'string') {
         return undefined;
@@ -11465,6 +12379,13 @@ class IntegrationAppApiClient {
     async delete(uri, data, options) {
         return this.makeApiRequest('DELETE', { ...(options !== null && options !== void 0 ? options : {}), url: uri, data });
     }
+    async createEventSource(uri, queryParams) {
+        const token = await this.getToken();
+        const allParams = { ...queryParams, token };
+        const queryString = qs.stringify(omitBy(allParams, isEmptyValue));
+        const urlWithToken = `${this.apiUri}/${uri}?${queryString}`;
+        return new EventSource(urlWithToken);
+    }
     async getEmbedUri(page, pageParams, options) {
         var _a;
         const paramsWithToken = {
@@ -11645,6 +12566,9 @@ class IntegrationAppClient extends IntegrationAppApiClient {
     get scenarios() {
         return new ScenariosAccessor(this);
     }
+    async createEventSource(uri, queryParams) {
+        return super.createEventSource(uri, queryParams);
+    }
     async connectionRequest(connectionId, uri, data) {
         return this.post(`connections/${connectionId}/execute-request`, {
             key: uri,
@@ -11657,13 +12581,16 @@ injectFormulaCatalog(getFormula, isFormula, hasFormulas);
 
 exports.ACTIONS = ACTIONS;
 exports.AccessDeniedError = AccessDeniedError;
+exports.Action = Action;
 exports.ActionAccessor = ActionAccessor;
+exports.ActionDependency = ActionDependency;
 exports.ActionInstanceAccessor = ActionInstanceAccessor;
 exports.ActionInstanceSetupError = ActionInstanceSetupError;
 exports.ActionInstancesAccessor = ActionInstancesAccessor;
 exports.ActionRunError = ActionRunError;
+exports.ActionRunResponse = ActionRunResponse;
 exports.ActionsAccessor = ActionsAccessor;
-exports.ApiRequestSpecSchema = ApiRequestSpecSchema;
+exports.ApiRequestSpec = ApiRequestSpec;
 exports.AppDataSchemaAccessor = AppDataSchemaAccessor;
 exports.AppDataSchemaInstanceAccessor = AppDataSchemaInstanceAccessor;
 exports.AppDataSchemaInstancesAccessor = AppDataSchemaInstancesAccessor;
@@ -11672,8 +12599,34 @@ exports.AppEventSubscriptionAccessor = AppEventSubscriptionAccessor;
 exports.AppEventSubscriptionsAccessor = AppEventSubscriptionsAccessor;
 exports.AppEventTypeAccessor = AppEventTypeAccessor;
 exports.AppEventTypesAccessor = AppEventTypesAccessor;
+exports.AppliedToIntegrations = AppliedToIntegrations;
 exports.BadRequestError = BadRequestError;
+exports.BaseAction = BaseAction;
+exports.BaseActionInstance = BaseActionInstance;
+exports.BaseActionRunLogRecord = BaseActionRunLogRecord;
+exports.BaseAppDataSchema = BaseAppDataSchema;
+exports.BaseAppDataSchemaInstance = BaseAppDataSchemaInstance;
+exports.BaseAppEventSubscription = BaseAppEventSubscription;
+exports.BaseAppEventType = BaseAppEventType;
+exports.BaseConnection = BaseConnection;
+exports.BaseCustomer = BaseCustomer;
+exports.BaseDataLinkTable = BaseDataLinkTable;
+exports.BaseDataLinkTableInstance = BaseDataLinkTableInstance;
+exports.BaseDataSource = BaseDataSource;
+exports.BaseDataSourceInstance = BaseDataSourceInstance;
+exports.BaseExternalEvent = BaseExternalEvent;
+exports.BaseExternalEventLogRecord = BaseExternalEventLogRecord;
+exports.BaseExternalEventPull = BaseExternalEventPull;
+exports.BaseExternalEventSubscription = BaseExternalEventSubscription;
+exports.BaseFieldMapping = BaseFieldMapping;
+exports.BaseFieldMappingInstance = BaseFieldMappingInstance;
+exports.BaseFlow = BaseFlow;
+exports.BaseFlowInstance = BaseFlowInstance;
+exports.BaseFlowRun = BaseFlowRun;
+exports.BaseIntegration = BaseIntegration;
 exports.BaseMembraneInterface = BaseMembraneInterface;
+exports.BaseScenario = BaseScenario;
+exports.BaseScreen = BaseScreen;
 exports.BaseWorkspaceElement = BaseWorkspaceElement;
 exports.CONNECTOR_AUTH_TYPES = CONNECTOR_AUTH_TYPES;
 exports.CONNECTOR_CATEGORIES = CONNECTOR_CATEGORIES;
@@ -11683,8 +12636,12 @@ exports.CONNECTOR_EVENTS_DIR = CONNECTOR_EVENTS_DIR;
 exports.CONNECTOR_GLOBAL_WEBHOOKS_DIR = CONNECTOR_GLOBAL_WEBHOOKS_DIR;
 exports.CONNECTOR_METHOD_IMPLEMENTATION_SUFFIXES = CONNECTOR_METHOD_IMPLEMENTATION_SUFFIXES;
 exports.CONNECTOR_OPERATIONS_DIR = CONNECTOR_OPERATIONS_DIR;
+exports.CommonInstancesListQuery = CommonInstancesListQuery;
+exports.CommonIntegrationOrConnectionQuery = CommonIntegrationOrConnectionQuery;
+exports.CommonListElementsQuery = CommonListElementsQuery;
 exports.ConcurrencyError = ConcurrencyError;
 exports.ConfigurationError = ConfigurationError;
+exports.Connection = Connection;
 exports.ConnectionAccessor = ConnectionAccessor;
 exports.ConnectionDataCollectionAccessor = ConnectionDataCollectionAccessor;
 exports.ConnectionError = ConnectionError;
@@ -11696,8 +12653,11 @@ exports.ConnectionLevelFieldMappingAccessor = ConnectionLevelFieldMappingAccesso
 exports.ConnectionLevelFieldMappingsAccessor = ConnectionLevelFieldMappingsAccessor;
 exports.ConnectionLevelFlowAccessor = ConnectionLevelFlowAccessor;
 exports.ConnectionLevelFlowsAccessor = ConnectionLevelFlowsAccessor;
+exports.ConnectionMessagePayload = ConnectionMessagePayload;
 exports.ConnectionOperationAccessor = ConnectionOperationAccessor;
 exports.ConnectionProxy = ConnectionProxy;
+exports.ConnectionRequest = ConnectionRequest;
+exports.ConnectionSelector = ConnectionSelector;
 exports.ConnectionSpec = ConnectionSpec;
 exports.ConnectionsAccessor = ConnectionsAccessor;
 exports.ConnectorAuthMethodTypes = ConnectorAuthMethodTypes;
@@ -11707,48 +12667,60 @@ exports.ConnectorDataLocationTypes = ConnectorDataLocationTypes;
 exports.ConnectorEventHandlerMethods = ConnectorEventHandlerMethods;
 exports.ConnectorOperationMethodImplementationTypes = ConnectorOperationMethodImplementationTypes;
 exports.CopilotActivityScope = CopilotActivityScope;
+exports.CreateActionInstanceRequest = CreateActionInstanceRequest;
+exports.CreateActionRequest = CreateActionRequest;
 exports.CreateConnectionRequest = CreateConnectionRequest;
+exports.CreateCustomerRequest = CreateCustomerRequest;
+exports.CreateDataSourceInstanceRequest = CreateDataSourceInstanceRequest;
+exports.CreateDataSourceRequest = CreateDataSourceRequest;
+exports.CreateFlowNodeRequest = CreateFlowNodeRequest;
+exports.CreateFlowRequest = CreateFlowRequest;
+exports.CreateIntegrationRequest = CreateIntegrationRequest;
+exports.CreateScenarioRequest = CreateScenarioRequest;
 exports.CustomCodeError = CustomCodeError;
 exports.CustomerAccessor = CustomerAccessor;
+exports.CustomerSelector = CustomerSelector;
 exports.CustomersAccessor = CustomersAccessor;
 exports.DATA_RECORD_SCHEMA = DATA_RECORD_SCHEMA;
 exports.DEFAULT_FULL_SYNC_INTERVAL_SECONDS = DEFAULT_FULL_SYNC_INTERVAL_SECONDS;
 exports.DEFAULT_PULL_UPDATES_INTERVAL_SECONDS = DEFAULT_PULL_UPDATES_INTERVAL_SECONDS;
-exports.DataCollectionCreateRequestSchema = DataCollectionCreateRequestSchema;
-exports.DataCollectionCreateResponseSchema = DataCollectionCreateResponseSchema;
-exports.DataCollectionCreateSpecSchema = DataCollectionCreateSpecSchema;
-exports.DataCollectionDeleteRequestSchema = DataCollectionDeleteRequestSchema;
-exports.DataCollectionDeleteResponseSchema = DataCollectionDeleteResponseSchema;
-exports.DataCollectionDeleteSpecSchema = DataCollectionDeleteSpecSchema;
-exports.DataCollectionEventTypeSpecSchema = DataCollectionEventTypeSpecSchema;
-exports.DataCollectionEventsSpecSchema = DataCollectionEventsSpecSchema;
-exports.DataCollectionFindByIdRequestSchema = DataCollectionFindByIdRequestSchema;
-exports.DataCollectionFindByIdResponseSchema = DataCollectionFindByIdResponseSchema;
-exports.DataCollectionFindByIdSpecSchema = DataCollectionFindByIdSpecSchema;
-exports.DataCollectionFindRequestSchema = DataCollectionFindRequestSchema;
-exports.DataCollectionFindResponseSchema = DataCollectionFindResponseSchema;
-exports.DataCollectionFindSpecSchema = DataCollectionFindSpecSchema;
-exports.DataCollectionListRequestSchema = DataCollectionListRequestSchema;
-exports.DataCollectionListResponseDrilldownSchema = DataCollectionListResponseDrilldownSchema;
-exports.DataCollectionListResponseSchema = DataCollectionListResponseSchema;
-exports.DataCollectionListSpecSchema = DataCollectionListSpecSchema;
-exports.DataCollectionMatchRequestSchema = DataCollectionMatchRequestSchema;
-exports.DataCollectionMatchResponseSchema = DataCollectionMatchResponseSchema;
-exports.DataCollectionMatchSpecSchema = DataCollectionMatchSpecSchema;
-exports.DataCollectionMethodRequestSchema = DataCollectionMethodRequestSchema;
-exports.DataCollectionMethodSpecSchema = DataCollectionMethodSpecSchema;
-exports.DataCollectionSearchRequestSchema = DataCollectionSearchRequestSchema;
-exports.DataCollectionSearchResponseSchema = DataCollectionSearchResponseSchema;
-exports.DataCollectionSearchSpecSchema = DataCollectionSearchSpecSchema;
-exports.DataCollectionSpecSchema = DataCollectionSpecSchema;
-exports.DataCollectionUdmSpecSchema = DataCollectionUdmSpecSchema;
-exports.DataCollectionUdmsSpecSchema = DataCollectionUdmsSpecSchema;
-exports.DataCollectionUpdateRequestSchema = DataCollectionUpdateRequestSchema;
-exports.DataCollectionUpdateResponseSchema = DataCollectionUpdateResponseSchema;
-exports.DataCollectionUpdateSpecSchema = DataCollectionUpdateSpecSchema;
+exports.DataCollectionCreateRequest = DataCollectionCreateRequest;
+exports.DataCollectionCreateResponse = DataCollectionCreateResponse;
+exports.DataCollectionCreateSpec = DataCollectionCreateSpec;
+exports.DataCollectionDeleteRequest = DataCollectionDeleteRequest;
+exports.DataCollectionDeleteResponse = DataCollectionDeleteResponse;
+exports.DataCollectionDeleteSpec = DataCollectionDeleteSpec;
+exports.DataCollectionEventTypeSpec = DataCollectionEventTypeSpec;
+exports.DataCollectionEventsSpec = DataCollectionEventsSpec;
+exports.DataCollectionFindByIdRequest = DataCollectionFindByIdRequest;
+exports.DataCollectionFindByIdResponse = DataCollectionFindByIdResponse;
+exports.DataCollectionFindByIdSpec = DataCollectionFindByIdSpec;
+exports.DataCollectionFindRequest = DataCollectionFindRequest;
+exports.DataCollectionFindResponse = DataCollectionFindResponse;
+exports.DataCollectionFindSpec = DataCollectionFindSpec;
+exports.DataCollectionListRequest = DataCollectionListRequest;
+exports.DataCollectionListResponse = DataCollectionListResponse;
+exports.DataCollectionListResponseDrilldown = DataCollectionListResponseDrilldown;
+exports.DataCollectionListSpec = DataCollectionListSpec;
+exports.DataCollectionMatchRequest = DataCollectionMatchRequest;
+exports.DataCollectionMatchResponse = DataCollectionMatchResponse;
+exports.DataCollectionMatchSpec = DataCollectionMatchSpec;
+exports.DataCollectionMethodRequest = DataCollectionMethodRequest;
+exports.DataCollectionMethodSpec = DataCollectionMethodSpec;
+exports.DataCollectionSearchRequest = DataCollectionSearchRequest;
+exports.DataCollectionSearchResponse = DataCollectionSearchResponse;
+exports.DataCollectionSearchSpec = DataCollectionSearchSpec;
+exports.DataCollectionSpec = DataCollectionSpec;
+exports.DataCollectionUdmSpec = DataCollectionUdmSpec;
+exports.DataCollectionUdmsSpec = DataCollectionUdmsSpec;
+exports.DataCollectionUpdateRequest = DataCollectionUpdateRequest;
+exports.DataCollectionUpdateResponse = DataCollectionUpdateResponse;
+exports.DataCollectionUpdateSpec = DataCollectionUpdateSpec;
 exports.DataFilterCondition = DataFilterCondition;
 exports.DataForm = DataForm;
+exports.DataLink = DataLink;
 exports.DataLinkTableAccessor = DataLinkTableAccessor;
+exports.DataLinkTableConfig = DataLinkTableConfig;
 exports.DataLinkTableInstanceAccessor = DataLinkTableInstanceAccessor;
 exports.DataLinkTableInstancesAccessor = DataLinkTableInstancesAccessor;
 exports.DataLinkTablesAccessor = DataLinkTablesAccessor;
@@ -11758,10 +12730,13 @@ exports.DataLocatorStep = DataLocatorStep;
 exports.DataLocatorStepArrayItem = DataLocatorStepArrayItem;
 exports.DataLocatorStepObjectProperty = DataLocatorStepObjectProperty;
 exports.DataRecordSchema = DataRecordSchema;
+exports.DataSchema = DataSchema;
 exports.DataSchemaSchema = DataSchemaSchema;
+exports.DataSource = DataSource;
 exports.DataSourceAccessor = DataSourceAccessor;
 exports.DataSourceInstanceAccessor = DataSourceInstanceAccessor;
 exports.DataSourceInstancesAccessor = DataSourceInstancesAccessor;
+exports.DataSourceUnitConfig = DataSourceUnitConfig;
 exports.DataSourcesAccessor = DataSourcesAccessor;
 exports.DependencyError = DependencyError;
 exports.DownstreamFlowNodeRunSchema = DownstreamFlowNodeRunSchema;
@@ -11770,20 +12745,44 @@ exports.ElementAccessor = ElementAccessor;
 exports.ElementInstanceAccessor = ElementInstanceAccessor;
 exports.ElementInstanceListAccessor = ElementInstanceListAccessor;
 exports.ElementListAccessor = ElementListAccessor;
+exports.ElementsExportFields = ElementsExportFields;
 exports.ErrorData = ErrorData;
 exports.ErrorDataSchema = ErrorDataSchema;
+exports.ExternalEvent = ExternalEvent;
 exports.ExternalEventSubscriptionAccessor = ExternalEventSubscriptionAccessor;
+exports.ExternalEventSubscriptionConfig = ExternalEventSubscriptionConfig;
 exports.ExternalEventSubscriptionsAccessor = ExternalEventSubscriptionsAccessor;
+exports.ExternalEventUnitConfig = ExternalEventUnitConfig;
 exports.FLOW_NODE_SPECS = FLOW_NODE_SPECS;
+exports.FieldMapping = FieldMapping;
 exports.FieldMappingAccessor = FieldMappingAccessor;
 exports.FieldMappingInstanceAccessor = FieldMappingInstanceAccessor;
 exports.FieldMappingInstancesAccessor = FieldMappingInstancesAccessor;
+exports.FieldMappingUnitConfig = FieldMappingUnitConfig;
 exports.FieldMappingsAccessor = FieldMappingsAccessor;
+exports.FindActionInstancesQuery = FindActionInstancesQuery;
+exports.FindActionsQuery = FindActionsQuery;
+exports.FindConnectionsQuery = FindConnectionsQuery;
 exports.FindConnectionsResponse = FindConnectionsResponse;
+exports.FindCustomersQuery = FindCustomersQuery;
+exports.FindDataSourceEventsQuery = FindDataSourceEventsQuery;
+exports.FindDataSourceInstanceSyncsQuery = FindDataSourceInstanceSyncsQuery;
+exports.FindDataSourceInstancesQuery = FindDataSourceInstancesQuery;
+exports.FindDataSourceSyncsQuery = FindDataSourceSyncsQuery;
+exports.FindDataSourcesQuery = FindDataSourcesQuery;
+exports.FindFlowInstancesQuery = FindFlowInstancesQuery;
+exports.FindFlowsQuery = FindFlowsQuery;
+exports.FindIntegrationsQuery = FindIntegrationsQuery;
+exports.FindScenariosQuery = FindScenariosQuery;
+exports.Flow = Flow;
 exports.FlowAccessor = FlowAccessor;
+exports.FlowInstance = FlowInstance;
 exports.FlowInstanceAccessor = FlowInstanceAccessor;
+exports.FlowInstanceNode = FlowInstanceNode;
 exports.FlowInstanceSetupError = FlowInstanceSetupError;
 exports.FlowInstancesAccessor = FlowInstancesAccessor;
+exports.FlowNode = FlowNode;
+exports.FlowNodeLink = FlowNodeLink;
 exports.FlowNodeRunOutputMetadataSchema = FlowNodeRunOutputMetadataSchema;
 exports.FlowNodeRunOutputSchema = FlowNodeRunOutputSchema;
 exports.FlowNodeRunOutputWithoutDownstreamRunsSchema = FlowNodeRunOutputWithoutDownstreamRunsSchema;
@@ -11794,10 +12793,16 @@ exports.FlowNodeRunResultSchema = FlowNodeRunResultSchema;
 exports.FlowNodeSpec = FlowNodeSpec;
 exports.FlowRunAccessor = FlowRunAccessor;
 exports.FlowRunError = FlowRunError;
+exports.FlowRunLaunchedBy = FlowRunLaunchedBy;
+exports.FlowRunNode = FlowRunNode;
 exports.FlowRunsAccessor = FlowRunsAccessor;
 exports.FlowsAccessor = FlowsAccessor;
 exports.Formula = Formula;
 exports.HTTP_REQUEST_SCHEMA = HTTP_REQUEST_SCHEMA;
+exports.HandyScenarioTemplateElement = HandyScenarioTemplateElement;
+exports.HttpRequestSpec = HttpRequestSpec;
+exports.IncludeArchivedQuery = IncludeArchivedQuery;
+exports.Integration = Integration;
 exports.IntegrationAccessor = IntegrationAccessor;
 exports.IntegrationAppClient = IntegrationAppClient;
 exports.IntegrationAppError = IntegrationAppError;
@@ -11812,24 +12817,52 @@ exports.IntegrationLevelFlowsListAccessor = IntegrationLevelFlowsListAccessor;
 exports.IntegrationsAccessor = IntegrationsAccessor;
 exports.InternalError = InternalError;
 exports.InvalidLocatorError = InvalidLocatorError;
+exports.ListActionInstancesForConnectionQuery = ListActionInstancesForConnectionQuery;
+exports.ListActionsForIntegrationQuery = ListActionsForIntegrationQuery;
+exports.ListDataSourceInstancesForConnectionQuery = ListDataSourceInstancesForConnectionQuery;
+exports.ListDataSourcesForIntegrationQuery = ListDataSourcesForIntegrationQuery;
+exports.ListFlowInstancesForConnectionQuery = ListFlowInstancesForConnectionQuery;
+exports.ListFlowsForIntegrationQuery = ListFlowsForIntegrationQuery;
 exports.MIN_FULL_SYNC_INTERVAL_SECONDS = MIN_FULL_SYNC_INTERVAL_SECONDS;
 exports.MIN_PULL_UPDATES_INTERVAL_SECONDS = MIN_PULL_UPDATES_INTERVAL_SECONDS;
+exports.MinimalConnector = MinimalConnector;
 exports.NotAuthenticatedError = NotAuthenticatedError;
 exports.NotFoundError = NotFoundError;
 exports.OAUTH1_CONFIG_SCHEMA = OAUTH1_CONFIG_SCHEMA;
 exports.OAUTH_CONFIG_SCHEMA = OAUTH_CONFIG_SCHEMA;
+exports.OpenNewConnectionOptions = OpenNewConnectionOptions;
 exports.PARALLEL_EXECUTION_LIMITS = PARALLEL_EXECUTION_LIMITS;
+exports.PaginationQuery = PaginationQuery;
 exports.PaginationResponse = PaginationResponse;
 exports.RATE_LIMITS = RATE_LIMITS;
 exports.RateLimitExceededError = RateLimitExceededError;
+exports.ResetFlowInstanceOptions = ResetFlowInstanceOptions;
+exports.RunFlowOptions = RunFlowOptions;
+exports.Scenario = Scenario;
 exports.ScenarioAccessor = ScenarioAccessor;
+exports.ScenarioElement = ScenarioElement;
+exports.ScenarioElementApi = ScenarioElementApi;
+exports.ScenarioTemplate = ScenarioTemplate;
+exports.ScenarioTemplateElements = ScenarioTemplateElements;
+exports.ScenarioToDo = ScenarioToDo;
+exports.ScenarioToDoApi = ScenarioToDoApi;
 exports.ScenariosAccessor = ScenariosAccessor;
 exports.ScreenAccessor = ScreenAccessor;
+exports.ScreenBlock = ScreenBlock;
 exports.ScreensAccessor = ScreensAccessor;
+exports.SearchQuery = SearchQuery;
 exports.SelfAccessor = SelfAccessor;
 exports.UNIFIED_DATA_MODELS = UNIFIED_DATA_MODELS;
 exports.UnitRunError = UnitRunError;
+exports.UpdateActionInstanceRequest = UpdateActionInstanceRequest;
+exports.UpdateActionRequest = UpdateActionRequest;
 exports.UpdateConnectionRequest = UpdateConnectionRequest;
+exports.UpdateCustomerRequest = UpdateCustomerRequest;
+exports.UpdateDataSourceInstanceRequest = UpdateDataSourceInstanceRequest;
+exports.UpdateDataSourceRequest = UpdateDataSourceRequest;
+exports.UpdateFlowRequest = UpdateFlowRequest;
+exports.UpdateIntegrationRequest = UpdateIntegrationRequest;
+exports.UpdateScenarioRequest = UpdateScenarioRequest;
 exports.UpstreamFlowNodeRunSchema = UpstreamFlowNodeRunSchema;
 exports.UserAccessor = UserAccessor;
 exports.UsersAccessor = UsersAccessor;