@membranehq/sdk 0.9.3 → 0.9.4

package/dist/index.browser.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var zod = require('zod');
+var z = require('zod');
 var jsConvertCase = require('js-convert-case');
 var humanparser = require('humanparser');
 var jsonata = require('jsonata');
@@ -46,14 +46,14 @@ exports.ConcurrencyErrorKey = void 0;
 (function (ConcurrencyErrorKey) {
     ConcurrencyErrorKey["LOCK_TIMEOUT"] = "lock_timeout";
 })(exports.ConcurrencyErrorKey || (exports.ConcurrencyErrorKey = {}));
-const ErrorDataSchema = zod.z.lazy(() => zod.z.object({
-    type: zod.z.enum(exports.ErrorType).optional(),
-    key: zod.z.string().optional(),
-    message: zod.z.string(),
-    data: zod.z.any().optional(),
-    stack: zod.z.any().optional(),
-    causedByError: zod.z.lazy(() => ErrorDataSchema).optional(),
-    logs: zod.z.array(zod.z.any()).optional(),
+const ErrorDataSchema = z.z.lazy(() => z.z.object({
+    type: z.z.enum(exports.ErrorType).optional(),
+    key: z.z.string().optional(),
+    message: z.z.string(),
+    data: z.z.any().optional(),
+    stack: z.z.any().optional(),
+    causedByError: z.z.lazy(() => ErrorDataSchema).optional(),
+    logs: z.z.array(z.z.any()).optional(),
 }));
 function isMembraneError(error) {
     return error && error.isMembraneError;
@@ -184,6 +184,7 @@ class InsufficientCreditsError extends MembraneError {
         this.data.type = exports.ErrorType.INSUFFICIENT_CREDIT;
     }
 }
+const IntegrationAppError = MembraneError;
 
 exports.DataBuilderFormulaType = void 0;
 (function (DataBuilderFormulaType) {
@@ -1320,41 +1321,41 @@ function createSchemaForObject(obj) {
     return schema;
 }
 
-const DataSchema = zod.z.lazy(() => zod.z
+const DataSchema = z.z.lazy(() => z.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(zod.z.string(), DataSchema).optional(),
+    title: z.z.string().optional(),
+    description: z.z.string().optional(),
+    type: z.z.union([z.z.string(), z.z.array(z.z.string())]).optional(),
+    format: z.z.string().optional(),
+    properties: z.z.record(z.z.string(), 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
+    additionalProperties: z.z.union([z.z.boolean(), DataSchema]).optional(),
+    enum: z.z.array(z.z.string()).optional(),
+    referenceRecords: z.z.array(z.z.any()).optional(),
+    referenceCollection: z.z
         .object({
-        key: zod.z.any().optional(),
-        parameters: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+        key: z.z.any().optional(),
+        parameters: z.z.record(z.z.string(), z.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(),
+    referenceUdm: z.z.string().optional(),
+    default: z.z.any().optional(),
+    allowCustom: z.z.boolean().optional(),
+    $ref: z.z.string().optional(),
+    required: z.z.array(z.z.string()).optional(),
+    minLength: z.z.number().optional(),
+    maxLength: z.z.number().optional(),
+    minimum: z.z.number().optional(),
+    maximum: z.z.number().optional(),
+    maxItems: z.z.number().optional(),
+    readOnly: z.z.boolean().optional(),
+    writeOnly: z.z.boolean().optional(),
+    examples: z.z.array(z.z.any()).optional(),
+    anyOf: z.z.array(DataSchema).optional(),
+    isImplied: z.z.boolean().optional(),
+    isSensitive: z.z.boolean().optional(),
+    referenceCollectionPath: z.z.string().optional(),
+    referenceCollectionUri: z.z.string().optional(),
 })
     .passthrough());
 
@@ -3377,7 +3378,7 @@ function getFormula(value) {
     return undefined;
 }
 
-const zodBooleanCoercion = () => zod.z.preprocess((val) => {
+const zodBooleanCoercion = () => z.z.preprocess((val) => {
     if (typeof val === 'boolean')
         return val;
     if (typeof val === 'string') {
@@ -3391,27 +3392,27 @@ const zodBooleanCoercion = () => zod.z.preprocess((val) => {
     if (typeof val === 'number')
         return Boolean(val);
     return Boolean(val);
-}, zod.z.boolean());
+}, z.z.boolean());
 
-const IncludeArchivedQuery = zod.z.object({
+const IncludeArchivedQuery = z.z.object({
     includeArchived: zodBooleanCoercion().optional(),
 });
-const SearchQuery = zod.z.object({
-    search: zod.z.string().optional(),
+const SearchQuery = z.z.object({
+    search: z.z.string().optional(),
 });
-const PaginationQuery = zod.z.object({
-    limit: zod.z.coerce.number().int().min(1).max(1000).optional(),
-    cursor: zod.z.string().optional(),
+const PaginationQuery = z.z.object({
+    limit: z.z.coerce.number().int().min(1).max(1000).optional(),
+    cursor: z.z.string().optional(),
 });
 const CommonListElementsQuery = SearchQuery.merge(PaginationQuery).merge(IncludeArchivedQuery);
 const CommonInstancesListQuery = CommonListElementsQuery.extend({
-    userId: zod.z.string().optional(),
-    instanceKey: zod.z.string().optional(),
+    userId: z.z.string().optional(),
+    instanceKey: z.z.string().optional(),
 });
-const CommonIntegrationOrConnectionQuery = zod.z.object({
-    connectionId: zod.z.string().optional(),
-    integrationId: zod.z.string().optional(),
-    integrationKey: zod.z.string().optional(),
+const CommonIntegrationOrConnectionQuery = z.z.object({
+    connectionId: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    integrationKey: z.z.string().optional(),
 });
 class PaginationResponse {
 }
@@ -3474,54 +3475,54 @@ exports.WorkspaceElementDependencyType = void 0;
     WorkspaceElementDependencyType["Configuration"] = "CONFIGURATION";
     WorkspaceElementDependencyType["Parent"] = "PARENT";
 })(exports.WorkspaceElementDependencyType || (exports.WorkspaceElementDependencyType = {}));
-const BaseWorkspaceElement = zod.z.object({
-    id: zod.z.string(),
-    name: zod.z.string(),
-});
-const BaseMembraneInterfaceEditableProperties = zod.z.object({
-    uuid: zod.z.string().optional(),
-    key: zod.z.string().optional(),
-    name: zod.z.string().optional(),
-    description: zod.z.string().optional(),
-    meta: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-});
-const BaseMembraneInterfaceReadOnlyProperties = zod.z.object({
-    name: zod.z.string(),
-    state: zod.z.enum(exports.WorkspaceElementState).optional(),
-    errors: zod.z.array(ErrorDataSchema).optional(),
-    revision: zod.z.string().optional(),
-    createdAt: zod.z.string().optional(),
-    updatedAt: zod.z.string().optional(),
-    archivedAt: zod.z.string().optional(),
-    isDeactivated: zod.z.boolean().optional(),
+const BaseWorkspaceElement = z.z.object({
+    id: z.z.string(),
+    name: z.z.string(),
+});
+const BaseMembraneInterfaceEditableProperties = z.z.object({
+    uuid: z.z.string().optional(),
+    key: z.z.string().optional(),
+    name: z.z.string().optional(),
+    description: z.z.string().optional(),
+    meta: z.z.record(z.z.string(), z.z.any()).optional(),
+});
+const BaseMembraneInterfaceReadOnlyProperties = z.z.object({
+    name: z.z.string(),
+    state: z.z.enum(exports.WorkspaceElementState).optional(),
+    errors: z.z.array(ErrorDataSchema).optional(),
+    revision: z.z.string().optional(),
+    createdAt: z.z.string().optional(),
+    updatedAt: z.z.string().optional(),
+    archivedAt: z.z.string().optional(),
+    isDeactivated: z.z.boolean().optional(),
 });
 const BaseMembraneInterface = BaseWorkspaceElement.merge(BaseMembraneInterfaceEditableProperties).merge(BaseMembraneInterfaceReadOnlyProperties);
 const BaseIntegrationLevelMembraneInterfaceEditableProperties = BaseMembraneInterfaceEditableProperties.extend({
-    integrationId: zod.z.string().optional(),
-    integrationUuid: zod.z.string().optional(),
-    parentId: zod.z.string().optional(),
-    parentUuid: zod.z.string().optional(),
-    connectionId: zod.z.string().optional(),
-    instanceKey: zod.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    integrationUuid: z.z.string().optional(),
+    parentId: z.z.string().optional(),
+    parentUuid: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    instanceKey: z.z.string().optional(),
 });
 const BaseIntegrationLevelMembraneInterfaceReadOnlyProperties = BaseMembraneInterfaceReadOnlyProperties.extend({
-    isCustomized: zod.z.boolean().optional(),
+    isCustomized: z.z.boolean().optional(),
 });
 const BaseIntegrationLevelMembraneInterfaceExportProperties = BaseMembraneInterfaceEditableProperties.extend({
-    integrationUuid: zod.z.string().optional(),
-    parentUuid: zod.z.string().optional(),
+    integrationUuid: z.z.string().optional(),
+    parentUuid: z.z.string().optional(),
 });
-const IntegrationLevelMembraneInterfaceSelectorQuery = zod.z.object({
-    layer: zod.z.enum(['universal', 'integration', 'connection']).optional(),
-    integrationKey: zod.z.string().optional(),
-    integrationId: zod.z.string().optional(),
-    connectionId: zod.z.string().optional(),
-    instanceKey: zod.z.string().optional(),
+const IntegrationLevelMembraneInterfaceSelectorQuery = z.z.object({
+    layer: z.z.enum(['universal', 'integration', 'connection']).optional(),
+    integrationKey: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    instanceKey: z.z.string().optional(),
 });
 const FindIntegrationLevelMembraneInterfaceQuery = IntegrationLevelMembraneInterfaceSelectorQuery.extend(CommonListElementsQuery.shape).extend({
-    parentId: zod.z.string().optional(),
-    universalParentId: zod.z.string().optional(),
-    userId: zod.z.string().optional(),
+    parentId: z.z.string().optional(),
+    universalParentId: z.z.string().optional(),
+    userId: z.z.string().optional(),
 });
 const BaseIntegrationLevelMembraneInterface = BaseMembraneInterface.merge(BaseIntegrationLevelMembraneInterfaceEditableProperties).merge(BaseIntegrationLevelMembraneInterfaceReadOnlyProperties);
 
@@ -3561,20 +3562,20 @@ exports.FieldMappingDirection = void 0;
     FieldMappingDirection["EXPORT"] = "export";
     FieldMappingDirection["BOTH"] = "both";
 })(exports.FieldMappingDirection || (exports.FieldMappingDirection = {}));
-const FieldMappingSpecificProperties = zod.z.object({
-    connectionId: zod.z.string().optional(),
-    fieldMappingId: zod.z.string().optional(),
-    universalFieldMappingId: zod.z.string().optional(),
-    dataSourceKey: zod.z.string().optional(),
+const FieldMappingSpecificProperties = z.z.object({
+    connectionId: z.z.string().optional(),
+    fieldMappingId: z.z.string().optional(),
+    universalFieldMappingId: z.z.string().optional(),
+    dataSourceKey: z.z.string().optional(),
     appSchema: DataSchema.optional(),
-    direction: zod.z.enum(exports.FieldMappingDirection).optional(),
-    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(),
+    direction: z.z.enum(exports.FieldMappingDirection).optional(),
+    defaultImportValue: z.z.any().optional(),
+    defaultExportValue: z.z.any().optional(),
+    importValue: z.z.any().optional(),
+    exportValue: z.z.any().optional(),
+    frozenImportFields: z.z.any().optional(),
+    frozenExportFields: z.z.any().optional(),
+    frozenUnifiedExportFields: z.z.any().optional(),
 });
 const FieldMappingEditableProperties = BaseIntegrationLevelMembraneInterfaceEditableProperties.omit({
     parentId: true,
@@ -3585,18 +3586,18 @@ const FieldMappingExportProperties = BaseIntegrationLevelMembraneInterfaceExport
     universalFieldMappingId: true,
 });
 const FieldMappingReadOnlyProperties = BaseIntegrationLevelMembraneInterfaceReadOnlyProperties.extend({
-    universalFieldMappingRevision: zod.z.string().optional(),
+    universalFieldMappingRevision: z.z.string().optional(),
 });
 const BaseFieldMapping = BaseMembraneInterface.merge(FieldMappingEditableProperties).merge(FieldMappingReadOnlyProperties);
-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(),
+const FieldMappingUnitConfig = z.z.object({
+    key: z.z.string().optional(),
+    input: z.z.any().optional(),
+    includeRawFields: z.z.any().optional(),
+    importValue: z.z.any().optional(),
+    exportValue: z.z.any().optional(),
+    default: z.z.any().optional(),
+    defaultUnifiedValue: z.z.any().optional(),
+    defaultValue: z.z.any().optional(),
     appSchema: DataSchema.optional(),
 });
 
@@ -3702,18 +3703,18 @@ exports.ActionDependencyType = void 0;
     ActionDependencyType["FieldMapping"] = "FieldMapping";
     ActionDependencyType["DataSource"] = "DataSource";
 })(exports.ActionDependencyType || (exports.ActionDependencyType = {}));
-const ActionDependency = zod.z.object({
-    type: zod.z.enum(exports.ActionDependencyType),
-    key: zod.z.string(),
-    element: zod.z.any().optional(),
-});
-const ActionSpecificProperties = zod.z.object({
-    connectionId: zod.z.string().optional(),
-    instanceKey: zod.z.string().optional(),
+const ActionDependency = z.z.object({
+    type: z.z.enum(exports.ActionDependencyType),
+    key: z.z.string(),
+    element: z.z.any().optional(),
+});
+const ActionSpecificProperties = z.z.object({
+    connectionId: z.z.string().optional(),
+    instanceKey: z.z.string().optional(),
     inputSchema: DataSchema.optional(),
-    type: zod.z.enum(exports.ActionType).optional(),
-    config: zod.z.object({}).loose().optional(),
-    outputMapping: zod.z.any().optional(),
+    type: z.z.enum(exports.ActionType).optional(),
+    config: z.z.object({}).loose().optional(),
+    outputMapping: z.z.any().optional(),
     customOutputSchema: DataSchema.optional(),
 });
 const ActionEditableProperties = BaseIntegrationLevelMembraneInterfaceEditableProperties.extend(ActionSpecificProperties.shape);
@@ -3721,40 +3722,40 @@ const ActionExportProperties = BaseIntegrationLevelMembraneInterfaceExportProper
     connectionId: true,
 });
 const ActionReadOnlyProperties = BaseIntegrationLevelMembraneInterfaceReadOnlyProperties.extend({
-    universalParentId: zod.z.string().optional(),
-    userId: zod.z.string().optional(),
-    outputSchema: zod.z.any().optional(),
+    universalParentId: z.z.string().optional(),
+    userId: z.z.string().optional(),
+    outputSchema: z.z.any().optional(),
 });
 const BaseAction = BaseMembraneInterface.merge(ActionEditableProperties).merge(ActionReadOnlyProperties);
 const BaseActionInstance = BaseAction;
 
-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(), zod.z.string()).optional(),
-    headers: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-    query: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-    data: zod.z.any().optional(),
+const ConnectionRequest = z.z.object({
+    path: z.z.any(),
+    method: z.z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']).optional(),
+    pathParameters: z.z.record(z.z.string(), z.z.string()).optional(),
+    headers: z.z.record(z.z.string(), z.z.string()).optional(),
+    query: z.z.record(z.z.string(), z.z.string()).optional(),
+    data: z.z.any().optional(),
 });
 const BaseConnection = BaseWorkspaceElement.extend({
-    name: zod.z.string(),
-    userId: zod.z.string(),
-    isTest: zod.z.boolean().optional(),
-    disconnected: zod.z.boolean().optional(),
-    isDefunct: zod.z.boolean().optional(),
-    state: zod.z.enum(exports.WorkspaceElementState).optional(),
+    name: z.z.string(),
+    userId: z.z.string(),
+    isTest: z.z.boolean().optional(),
+    disconnected: z.z.boolean().optional(),
+    isDefunct: z.z.boolean().optional(),
+    state: z.z.enum(exports.WorkspaceElementState).optional(),
     error: ErrorDataSchema.optional(),
-    integrationId: zod.z.string(),
-    authOptionKey: zod.z.string().optional(),
-    createdAt: zod.z.string(),
-    updatedAt: zod.z.string(),
-    lastActiveAt: zod.z.string().optional(),
-    nextCredentialsRefreshAt: zod.z.string().optional(),
-    nextRetryTimestamp: zod.z.string().optional(),
-    retryAttempts: zod.z.number().optional(),
-    archivedAt: zod.z.string().optional(),
-    isDeactivated: zod.z.boolean().optional(),
-    meta: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    integrationId: z.z.string(),
+    authOptionKey: z.z.string().optional(),
+    createdAt: z.z.string(),
+    updatedAt: z.z.string(),
+    lastActiveAt: z.z.string().optional(),
+    nextCredentialsRefreshAt: z.z.string().optional(),
+    nextRetryTimestamp: z.z.string().optional(),
+    retryAttempts: z.z.number().optional(),
+    archivedAt: z.z.string().optional(),
+    isDeactivated: z.z.boolean().optional(),
+    meta: z.z.record(z.z.string(), z.z.any()).optional(),
 });
 class ConnectionSpec {
     constructor(opts) {
@@ -4079,27 +4080,27 @@ 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(),
-    name: zod.z.string().optional(),
-    uri: zod.z.string().optional(),
-    iconUri: zod.z.string().optional(),
-    fields: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    udm: zod.z.string().optional(),
-    unifiedFields: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    rawFields: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    createdTime: zod.z.string().optional(),
-    updatedTime: zod.z.string().optional(),
-    deletedTime: zod.z.string().optional(),
-    createdById: zod.z.string().optional(),
-    updatedById: zod.z.string().optional(),
+const MinimalConnector = z.z.object({
+    id: z.z.string(),
+    key: z.z.string(),
+    name: z.z.string(),
+    logoUri: z.z.string(),
+});
+
+const DataRecordSchema = z.z.object({
+    id: z.z.string(),
+    name: z.z.string().optional(),
+    uri: z.z.string().optional(),
+    iconUri: z.z.string().optional(),
+    fields: z.z.record(z.z.string(), z.z.any()).optional(),
+    udm: z.z.string().optional(),
+    unifiedFields: z.z.record(z.z.string(), z.z.any()).optional(),
+    rawFields: z.z.record(z.z.string(), z.z.any()).optional(),
+    createdTime: z.z.string().optional(),
+    updatedTime: z.z.string().optional(),
+    deletedTime: z.z.string().optional(),
+    createdById: z.z.string().optional(),
+    updatedById: z.z.string().optional(),
 });
 exports.DataCollectionEventType = void 0;
 (function (DataCollectionEventType) {
@@ -8236,40 +8237,40 @@ const DataLocationTypeCollection = {
 };
 const ConnectorDataCollectionMethodKeys = Object.keys(DataLocationTypeCollection.methods);
 
-const ApiRequestSpec = zod.z.object({
-    path: zod.z.unknown(),
-    method: zod.z.unknown(),
+const ApiRequestSpec = z.z.object({
+    path: z.z.unknown(),
+    method: z.z.unknown(),
 });
-const DataCollectionMethodSpec = zod.z.object({
-    apiRequests: zod.z.array(ApiRequestSpec).optional(),
+const DataCollectionMethodSpec = z.z.object({
+    apiRequests: z.z.array(ApiRequestSpec).optional(),
 });
 const DataCollectionListSpec = DataCollectionMethodSpec.extend({
-    filterFields: zod.z.array(zod.z.string()).optional(),
+    filterFields: z.z.array(z.z.string()).optional(),
 });
 const DataCollectionSearchSpec = DataCollectionMethodSpec.extend({});
 const DataCollectionMatchSpec = DataCollectionMethodSpec.extend({
-    fields: zod.z.array(zod.z.string()).optional(),
+    fields: z.z.array(z.z.string()).optional(),
 });
 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(),
+    fields: z.z.array(z.z.string()).optional(),
+    requiredFields: z.z.array(z.z.string()).optional(),
+    excludedFields: z.z.array(z.z.string()).optional(),
 });
 const DataCollectionUpdateSpec = DataCollectionMethodSpec.extend({
-    fields: zod.z.array(zod.z.string()).optional(),
-    excludedFields: zod.z.array(zod.z.string()).optional(),
+    fields: z.z.array(z.z.string()).optional(),
+    excludedFields: z.z.array(z.z.string()).optional(),
 });
 const DataCollectionDeleteSpec = DataCollectionMethodSpec.extend({});
 const DataCollectionFindSpec = DataCollectionMethodSpec.extend({
-    queryFields: zod.z.array(zod.z.string()).optional(),
+    queryFields: z.z.array(z.z.string()).optional(),
 });
-const DataCollectionEventTypeSpec = zod.z.object({
-    type: zod.z.enum(['push', 'pull']),
-    isFullScan: zod.z.boolean().optional(),
-    isIdOnly: zod.z.boolean().optional(),
+const DataCollectionEventTypeSpec = z.z.object({
+    type: z.z.enum(['push', 'pull']),
+    isFullScan: z.z.boolean().optional(),
+    isIdOnly: z.z.boolean().optional(),
 });
-const DataCollectionEventsSpec = zod.z
+const DataCollectionEventsSpec = z.z
     .object({
     created: DataCollectionEventTypeSpec.optional(),
     updated: DataCollectionEventTypeSpec.optional(),
@@ -8277,16 +8278,16 @@ const DataCollectionEventsSpec = zod.z
     all: DataCollectionEventTypeSpec.optional(),
 })
     .catchall(DataCollectionEventTypeSpec);
-const DataCollectionUdmSpec = zod.z.object({
-    fields: zod.z.array(zod.z.string()).optional(),
-    extract: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    parse: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-});
-const DataCollectionUdmsSpec = zod.z.record(zod.z.string(), DataCollectionUdmSpec);
-const DataCollectionSpec = zod.z.object({
-    type: zod.z.literal('collection'),
-    key: zod.z.string().optional(),
-    name: zod.z.string(),
+const DataCollectionUdmSpec = z.z.object({
+    fields: z.z.array(z.z.string()).optional(),
+    extract: z.z.record(z.z.string(), z.z.any()).optional(),
+    parse: z.z.record(z.z.string(), z.z.any()).optional(),
+});
+const DataCollectionUdmsSpec = z.z.record(z.z.string(), DataCollectionUdmSpec);
+const DataCollectionSpec = z.z.object({
+    type: z.z.literal('collection'),
+    key: z.z.string().optional(),
+    name: z.z.string(),
     parametersSchema: DataSchema.optional(),
     fieldsSchema: DataSchema.optional(),
     list: DataCollectionListSpec.optional(),
@@ -8297,73 +8298,73 @@ const DataCollectionSpec = zod.z.object({
     update: DataCollectionUpdateSpec.optional(),
     delete: DataCollectionDeleteSpec.optional(),
     events: DataCollectionEventsSpec.optional(),
-    customFields: zod.z.boolean().optional(),
+    customFields: z.z.boolean().optional(),
     udm: DataCollectionUdmsSpec.optional(),
     find: DataCollectionFindSpec.optional(),
 });
-const DataCollectionMethodRequest = zod.z.object({
-    parameters: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+const DataCollectionMethodRequest = z.z.object({
+    parameters: z.z.record(z.z.string(), z.z.any()).optional(),
 });
-const DataCollectionFindRequest = zod.z.object({
-    query: zod.z.any().optional(),
-    cursor: zod.z.string().optional(),
+const DataCollectionFindRequest = z.z.object({
+    query: z.z.any().optional(),
+    cursor: z.z.string().optional(),
 });
-const DataCollectionFindResponse = zod.z.object({
-    records: zod.z.array(DataRecordSchema),
-    cursor: zod.z.string().optional(),
+const DataCollectionFindResponse = z.z.object({
+    records: z.z.array(DataRecordSchema),
+    cursor: z.z.string().optional(),
 });
 const DataCollectionListRequest = DataCollectionMethodRequest.extend({
-    filter: zod.z.any().optional(),
-    unifiedFilter: zod.z.any().optional(),
-    cursor: zod.z.string().optional(),
+    filter: z.z.any().optional(),
+    unifiedFilter: z.z.any().optional(),
+    cursor: z.z.string().optional(),
 });
-const DataCollectionListResponseDrilldown = zod.z.object({
-    parameters: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    filter: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+const DataCollectionListResponseDrilldown = z.z.object({
+    parameters: z.z.record(z.z.string(), z.z.any()).optional(),
+    filter: z.z.record(z.z.string(), z.z.any()).optional(),
 });
-const DataCollectionListResponse = zod.z.object({
-    records: zod.z.array(DataRecordSchema),
-    drilldowns: zod.z.array(DataCollectionListResponseDrilldown).optional(),
-    cursor: zod.z.string().optional(),
+const DataCollectionListResponse = z.z.object({
+    records: z.z.array(DataRecordSchema),
+    drilldowns: z.z.array(DataCollectionListResponseDrilldown).optional(),
+    cursor: z.z.string().optional(),
 });
 const DataCollectionSearchRequest = DataCollectionMethodRequest.extend({
-    query: zod.z.string(),
-    cursor: zod.z.string().optional(),
+    query: z.z.string(),
+    cursor: z.z.string().optional(),
 });
-const DataCollectionSearchResponse = zod.z.object({
-    records: zod.z.array(DataRecordSchema),
-    cursor: zod.z.string().optional(),
+const DataCollectionSearchResponse = z.z.object({
+    records: z.z.array(DataRecordSchema),
+    cursor: z.z.string().optional(),
 });
 const DataCollectionFindByIdRequest = DataCollectionMethodRequest.extend({
-    id: zod.z.string(),
-    udm: zod.z.string().optional(),
+    id: z.z.string(),
+    udm: z.z.string().optional(),
 });
-const DataCollectionFindByIdResponse = zod.z.object({
+const DataCollectionFindByIdResponse = z.z.object({
     record: DataRecordSchema,
 });
 const DataCollectionMatchRequest = DataCollectionMethodRequest.extend({
-    query: zod.z.record(zod.z.string(), zod.z.any()),
+    query: z.z.record(z.z.string(), z.z.any()),
 });
-const DataCollectionMatchResponse = zod.z.object({
+const DataCollectionMatchResponse = z.z.object({
     record: DataRecordSchema.optional(),
 });
 const DataCollectionCreateRequest = DataCollectionMethodRequest.extend({
-    fields: zod.z.record(zod.z.string(), zod.z.any()),
+    fields: z.z.record(z.z.string(), z.z.any()),
 });
-const DataCollectionCreateResponse = zod.z.object({
-    id: zod.z.string(),
+const DataCollectionCreateResponse = z.z.object({
+    id: z.z.string(),
 });
 const DataCollectionUpdateRequest = DataCollectionMethodRequest.extend({
-    id: zod.z.string(),
-    fields: zod.z.record(zod.z.string(), zod.z.any()),
+    id: z.z.string(),
+    fields: z.z.record(z.z.string(), z.z.any()),
 });
-const DataCollectionUpdateResponse = zod.z.object({
-    id: zod.z.string(),
+const DataCollectionUpdateResponse = z.z.object({
+    id: z.z.string(),
 });
 const DataCollectionDeleteRequest = DataCollectionMethodRequest.extend({
-    id: zod.z.string(),
+    id: z.z.string(),
 });
-const DataCollectionDeleteResponse = zod.z.object({});
+const DataCollectionDeleteResponse = z.z.object({});
 const ConnectorDataLocationTypes = {
     collection: DataLocationTypeCollection,
 };
@@ -8430,22 +8431,22 @@ const DEFAULT_PULL_UPDATES_INTERVAL_SECONDS = 60 * 5;
 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 DataSourceSpecificProperties = zod.z.object({
-    connectionId: zod.z.string().optional(),
-    dataSourceId: zod.z.string().optional(),
-    universalDataSourceId: 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(),
+const DataSourceSpecificProperties = z.z.object({
+    connectionId: z.z.string().optional(),
+    dataSourceId: z.z.string().optional(),
+    universalDataSourceId: z.z.string().optional(),
+    udm: z.z.string().optional(),
+    pullUpdatesIntervalSeconds: z.z.number().optional(),
+    fullSyncIntervalSeconds: z.z.number().optional(),
+    collectionKey: z.z.string().optional(),
+    collectionParameters: z.z.any().optional(),
 });
 const DataSourceEditableProperties = BaseIntegrationLevelMembraneInterfaceEditableProperties.omit({
     parentId: true,
 }).extend(DataSourceSpecificProperties.shape);
 const BackwardCompatibleDataSourceEditableProperties = DataSourceEditableProperties.extend({
-    path: zod.z.string().optional().meta({ deprecated: true }),
-    defaultPath: zod.z.string().optional().meta({ deprecated: true }),
+    path: z.z.string().optional().meta({ deprecated: true }),
+    defaultPath: z.z.string().optional().meta({ deprecated: true }),
 });
 const DataSourceExportProperties = BaseIntegrationLevelMembraneInterfaceExportProperties.extend(DataSourceSpecificProperties.shape).omit({
     connectionId: true,
@@ -8453,39 +8454,39 @@ const DataSourceExportProperties = BaseIntegrationLevelMembraneInterfaceExportPr
     universalDataSourceId: true,
 });
 const DataSourceReadOnlyProperties = BaseIntegrationLevelMembraneInterfaceReadOnlyProperties.extend({
-    universalDataSourceRevision: zod.z.string().optional(),
+    universalDataSourceRevision: z.z.string().optional(),
 });
 const BaseDataSource = BaseMembraneInterface.merge(DataSourceEditableProperties).merge(DataSourceReadOnlyProperties);
-const DataSourceUnitConfig = zod.z.object({
-    key: zod.z.any().optional(),
-    collectionKey: zod.z.any().optional(),
-    collectionParameters: zod.z.any().optional(),
-    udm: zod.z.any().optional(),
-    pullUpdatesIntervalSeconds: zod.z.number().optional(),
-    fullSyncIntervalSeconds: zod.z.number().optional(),
-    path: zod.z.any().optional(),
-    defaultPath: zod.z.any().optional(),
+const DataSourceUnitConfig = z.z.object({
+    key: z.z.any().optional(),
+    collectionKey: z.z.any().optional(),
+    collectionParameters: z.z.any().optional(),
+    udm: z.z.any().optional(),
+    pullUpdatesIntervalSeconds: z.z.number().optional(),
+    fullSyncIntervalSeconds: z.z.number().optional(),
+    path: z.z.any().optional(),
+    defaultPath: z.z.any().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(),
+    userId: z.z.string(),
+    revision: z.z.string(),
+    dataSourceRevision: z.z.string().optional(),
+    dataSourceId: z.z.string().optional(),
+    universalDataSourceId: z.z.string().optional(),
+    udm: z.z.string().optional(),
+    connectionId: z.z.string(),
+    integrationId: z.z.string(),
+    instanceKey: z.z.string().optional(),
+    collectionKey: z.z.string().optional(),
+    collectionParameters: z.z.any().optional(),
+    defaultCollectionKey: z.z.string().optional(),
+    defaultCollectionParameters: z.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(),
+    isCustomized: z.z.boolean().optional(),
+    errors: z.z.array(ErrorDataSchema).optional(),
+    pullUpdatesIntervalSeconds: z.z.number().optional(),
+    fullSyncIntervalSeconds: z.z.number().optional(),
 });
 
 exports.ExternalEventType = void 0;
@@ -8500,13 +8501,13 @@ exports.IncomingWebhooksState = void 0;
     IncomingWebhooksState["SUCCESS"] = "success";
     IncomingWebhooksState["ERROR"] = "error";
 })(exports.IncomingWebhooksState || (exports.IncomingWebhooksState = {}));
-const ExternalEventUnitConfig = zod.z.object({
-    type: zod.z.enum(exports.ExternalEventType),
+const ExternalEventUnitConfig = z.z.object({
+    type: z.z.enum(exports.ExternalEventType),
     dataSource: DataSourceUnitConfig.optional(),
-    eventKey: zod.z.string().optional(),
-    eventParameters: zod.z.any().optional(),
+    eventKey: z.z.string().optional(),
+    eventParameters: z.z.any().optional(),
 });
-const BaseExternalEvent = zod.z.object({
+const BaseExternalEvent = z.z.object({
     config: ExternalEventUnitConfig.optional(),
 });
 
@@ -8558,31 +8559,31 @@ exports.FlowRunLaunchedByTrigger = void 0;
     FlowRunLaunchedByTrigger["DataSourceTrigger"] = "data-source-trigger";
     FlowRunLaunchedByTrigger["ExternalEvent"] = "external-event";
 })(exports.FlowRunLaunchedByTrigger || (exports.FlowRunLaunchedByTrigger = {}));
-const FlowRunLaunchedBy = zod.z.object({
-    type: zod.z.enum(exports.FlowRunLaunchedByTrigger),
-    ids: zod.z.array(zod.z.string()).optional(),
-});
-const FlowRunNode = zod.z.object({
-    state: zod.z.enum(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.enum(exports.FlowRunState),
-    startTime: zod.z.string(),
-    endTime: zod.z.string().optional(),
-    errors: zod.z.array(ErrorDataSchema).optional(),
-    nodes: zod.z.record(zod.z.string(), FlowRunNode).optional(),
+const FlowRunLaunchedBy = z.z.object({
+    type: z.z.enum(exports.FlowRunLaunchedByTrigger),
+    ids: z.z.array(z.z.string()).optional(),
+});
+const FlowRunNode = z.z.object({
+    state: z.z.enum(exports.FlowRunNodeState),
+    runs: z.z.number().optional(),
+    erroredRuns: z.z.number().optional(),
+    outputs: z.z.number().optional(),
+});
+const BaseFlowRun = z.z.object({
+    id: z.z.string(),
+    name: z.z.string().optional(),
+    flowInstanceId: z.z.string(),
+    universalFlowId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    startNodeKey: z.z.string(),
+    userId: z.z.string(),
+    input: z.z.any().optional(),
+    state: z.z.enum(exports.FlowRunState),
+    startTime: z.z.string(),
+    endTime: z.z.string().optional(),
+    errors: z.z.array(ErrorDataSchema).optional(),
+    nodes: z.z.record(z.z.string(), FlowRunNode).optional(),
     launchedBy: FlowRunLaunchedBy.optional(),
 });
 
@@ -8592,69 +8593,69 @@ exports.FlowNodeRunStatus = void 0;
     FlowNodeRunStatus["FAILED"] = "failed";
     FlowNodeRunStatus["SKIPPED"] = "skipped";
 })(exports.FlowNodeRunStatus || (exports.FlowNodeRunStatus = {}));
-const UpstreamFlowNodeRunSchema = zod.z.object({
-    nodeKey: zod.z.string(),
-    runId: zod.z.string(),
-    outputId: zod.z.string(),
-});
-const DownstreamFlowNodeRunSchema = zod.z.object({
-    runId: zod.z.string(),
-    nodeKey: zod.z.string(),
-});
-const FlowNodeRunParametersSchema = zod.z.object({
-    id: zod.z.string(),
-    upstreamRuns: zod.z.array(UpstreamFlowNodeRunSchema),
-    input: zod.z.any(),
-});
-const FlowNodeRunOutputSchema = zod.z.object({
-    id: zod.z.string(),
-    data: zod.z.string(),
-    downstreamRuns: zod.z.array(DownstreamFlowNodeRunSchema),
-});
-const FlowNodeRunResultSchema = zod.z.object({
-    status: zod.z.enum(exports.FlowNodeRunStatus),
-    logs: zod.z.array(zod.z.any()),
-    outputs: zod.z.array(FlowNodeRunOutputSchema),
-    errors: zod.z.array(ErrorDataSchema),
+const UpstreamFlowNodeRunSchema = z.z.object({
+    nodeKey: z.z.string(),
+    runId: z.z.string(),
+    outputId: z.z.string(),
+});
+const DownstreamFlowNodeRunSchema = z.z.object({
+    runId: z.z.string(),
+    nodeKey: z.z.string(),
+});
+const FlowNodeRunParametersSchema = z.z.object({
+    id: z.z.string(),
+    upstreamRuns: z.z.array(UpstreamFlowNodeRunSchema),
+    input: z.z.any(),
+});
+const FlowNodeRunOutputSchema = z.z.object({
+    id: z.z.string(),
+    data: z.z.string(),
+    downstreamRuns: z.z.array(DownstreamFlowNodeRunSchema),
+});
+const FlowNodeRunResultSchema = z.z.object({
+    status: z.z.enum(exports.FlowNodeRunStatus),
+    logs: z.z.array(z.z.any()),
+    outputs: z.z.array(FlowNodeRunOutputSchema),
+    errors: z.z.array(ErrorDataSchema),
 });
 const FlowNodeRunRecordSchema = FlowNodeRunParametersSchema.merge(FlowNodeRunResultSchema);
-const FlowNodeRunOutputWithoutDownstreamRunsSchema = zod.z.object({
-    id: zod.z.string(),
-    data: zod.z.string(),
-});
-const FlowNodeRunOutputMetadataSchema = zod.z.object({
-    id: zod.z.string(),
-    downstreamRuns: zod.z.array(DownstreamFlowNodeRunSchema),
-});
-const FlowNodeRunRecordWithoutOutputsDataSchema = zod.z.object({
-    id: zod.z.string(),
-    upstreamRuns: zod.z.array(UpstreamFlowNodeRunSchema),
-    input: zod.z.any(),
-    status: zod.z.enum(exports.FlowNodeRunStatus),
-    logs: zod.z.array(zod.z.any()),
-    outputs: zod.z.array(FlowNodeRunOutputMetadataSchema),
-    errors: zod.z.array(ErrorDataSchema),
-});
-
-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 FlowNodeRunOutputWithoutDownstreamRunsSchema = z.z.object({
+    id: z.z.string(),
+    data: z.z.string(),
+});
+const FlowNodeRunOutputMetadataSchema = z.z.object({
+    id: z.z.string(),
+    downstreamRuns: z.z.array(DownstreamFlowNodeRunSchema),
+});
+const FlowNodeRunRecordWithoutOutputsDataSchema = z.z.object({
+    id: z.z.string(),
+    upstreamRuns: z.z.array(UpstreamFlowNodeRunSchema),
+    input: z.z.any(),
+    status: z.z.enum(exports.FlowNodeRunStatus),
+    logs: z.z.array(z.z.any()),
+    outputs: z.z.array(FlowNodeRunOutputMetadataSchema),
+    errors: z.z.array(ErrorDataSchema),
+});
+
+const FlowNodeLink = z.z.object({
+    key: z.z.string().optional(),
+    filter: z.z.any().optional(),
+    name: z.z.string().optional(),
+});
+const FlowNode = z.z.object({
+    type: z.z.string().optional(),
+    version: z.z.number().optional(),
+    name: z.z.string().optional(),
+    description: z.z.string().optional(),
+    config: z.z.any().optional(),
+    concurrency: z.z.number().optional(),
+    onError: z.z.enum(['stop', 'continue']).optional(),
+    ui: z.z.any().optional(),
+    inputSchema: z.z.any().optional(),
+    outputSchema: z.z.any().optional(),
+    outputExample: z.z.any().optional(),
+    links: z.z.array(FlowNodeLink).optional(),
+    isCustomized: z.z.boolean().optional(),
 });
 class FlowNodeSpec {
     constructor(args) {
@@ -8929,14 +8930,14 @@ const FLOW_NODE_SPECS = {
     [exports.FlowNodeType.RunAction]: RunAction,
 };
 
-const FlowSpecificProperties = zod.z.object({
-    flowId: zod.z.string().optional(),
-    universalFlowId: zod.z.string().optional(),
+const FlowSpecificProperties = z.z.object({
+    flowId: z.z.string().optional(),
+    universalFlowId: z.z.string().optional(),
     parametersSchema: DataSchema.optional(),
-    parameters: zod.z.any().optional(),
-    enabled: zod.z.boolean().optional(),
-    nodes: zod.z.record(zod.z.string(), FlowNode).optional(),
-    autoCreateInstances: zod.z.boolean().optional(),
+    parameters: z.z.any().optional(),
+    enabled: z.z.boolean().optional(),
+    nodes: z.z.record(z.z.string(), FlowNode).optional(),
+    autoCreateInstances: z.z.boolean().optional(),
 });
 const FlowEditableProperties = BaseIntegrationLevelMembraneInterfaceEditableProperties.omit({
     parentId: true,
@@ -8946,41 +8947,41 @@ const FlowExportProperties = BaseIntegrationLevelMembraneInterfaceExportProperti
     universalFlowId: true,
 });
 const FlowReadOnlyProperties = BaseIntegrationLevelMembraneInterfaceReadOnlyProperties.extend({
-    universalFlowRevision: zod.z.string().optional(),
+    universalFlowRevision: z.z.string().optional(),
 });
 const BaseFlow = BaseMembraneInterface.merge(FlowEditableProperties).merge(FlowReadOnlyProperties);
 
 const BaseIntegration = BaseMembraneInterface.extend({
-    logoUri: zod.z.string(),
-    connectorId: zod.z.string().optional(),
-    connectorVersion: zod.z.string().optional(),
-    oAuthCallbackUri: zod.z.string().optional(),
-    parameters: zod.z.any().optional(),
-    archivedAt: zod.z.string().optional(),
-    hasMissingParameters: zod.z.boolean().optional(),
-    hasDocumentation: zod.z.boolean().optional(),
-    hasOperations: zod.z.boolean().optional(),
-    operationsCount: zod.z.number().optional(),
-    hasData: zod.z.boolean().optional(),
-    dataCollectionsCount: zod.z.number().optional(),
-    hasEvents: zod.z.boolean().optional(),
-    eventsCount: zod.z.number().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(),
+    logoUri: z.z.string(),
+    connectorId: z.z.string().optional(),
+    connectorVersion: z.z.string().optional(),
+    oAuthCallbackUri: z.z.string().optional(),
+    parameters: z.z.any().optional(),
+    archivedAt: z.z.string().optional(),
+    hasMissingParameters: z.z.boolean().optional(),
+    hasDocumentation: z.z.boolean().optional(),
+    hasOperations: z.z.boolean().optional(),
+    operationsCount: z.z.number().optional(),
+    hasData: z.z.boolean().optional(),
+    dataCollectionsCount: z.z.number().optional(),
+    hasEvents: z.z.boolean().optional(),
+    eventsCount: z.z.number().optional(),
+    hasGlobalWebhooks: z.z.boolean().optional(),
+    hasUdm: z.z.boolean().optional(),
+    isTest: z.z.boolean().optional(),
+    appUuid: z.z.string().optional(),
+    isDeactivated: z.z.boolean().optional(),
+    authType: z.z.enum(CONNECTOR_AUTH_TYPES).optional(),
 });
 const IntegrationExportProperties = BaseMembraneInterfaceEditableProperties.extend({
-    logoUri: zod.z.string(),
-    connectorUuid: zod.z.string().optional(),
-    connectorVersion: zod.z.string().optional(),
-    oAuthCallbackUri: zod.z.string().optional(),
-    parameters: zod.z.any().optional(),
-    appUuid: zod.z.string().optional(),
-});
-const AppliedToIntegrations = (elementSchema) => zod.z.array(zod.z.object({
+    logoUri: z.z.string(),
+    connectorUuid: z.z.string().optional(),
+    connectorVersion: z.z.string().optional(),
+    oAuthCallbackUri: z.z.string().optional(),
+    parameters: z.z.any().optional(),
+    appUuid: z.z.string().optional(),
+});
+const AppliedToIntegrations = (elementSchema) => z.z.array(z.z.object({
     element: elementSchema,
     integration: BaseIntegration,
 }));
@@ -9005,27 +9006,27 @@ exports.IntegrationElementType = void 0;
     IntegrationElementType["EXTERNAL_EVENT"] = "external-event";
 })(exports.IntegrationElementType || (exports.IntegrationElementType = {}));
 
-const PackageElement = zod.z.object({
-    id: zod.z.string(),
-    type: zod.z.enum(exports.IntegrationElementType),
-    element: zod.z.any().optional(),
+const PackageElement = z.z.object({
+    id: z.z.string(),
+    type: z.z.enum(exports.IntegrationElementType),
+    element: z.z.any().optional(),
 });
-const PackageElementExport = zod.z.object({
-    uuid: zod.z.string(),
-    type: zod.z.enum(exports.IntegrationElementType),
-    element: zod.z.any().optional(),
+const PackageElementExport = z.z.object({
+    uuid: z.z.string(),
+    type: z.z.enum(exports.IntegrationElementType),
+    element: z.z.any().optional(),
 });
 const PackageEditableProperties = BaseIntegrationLevelMembraneInterfaceEditableProperties.extend({
-    scenarioTemplateId: zod.z.string().optional(),
-    elements: zod.z.array(PackageElement).optional(),
+    scenarioTemplateId: z.z.string().optional(),
+    elements: z.z.array(PackageElement).optional(),
 });
 const PackageExportProperties = BaseIntegrationLevelMembraneInterfaceExportProperties.extend({
-    elements: zod.z.array(PackageElementExport).optional(),
+    elements: z.z.array(PackageElementExport).optional(),
 });
-const PackageCalculatedProperties = zod.z.object({
-    key: zod.z.string(),
-    name: zod.z.string(),
-    isCustomized: zod.z.boolean().optional(),
+const PackageCalculatedProperties = z.z.object({
+    key: z.z.string(),
+    name: z.z.string(),
+    isCustomized: z.z.boolean().optional(),
 });
 const BasePackage = BaseMembraneInterface.merge(PackageEditableProperties).merge(PackageCalculatedProperties);
 
@@ -9040,52 +9041,52 @@ exports.ScreenBlockType = void 0;
     ScreenBlockType["DataSource"] = "data-source";
     ScreenBlockType["Action"] = "action";
 })(exports.ScreenBlockType || (exports.ScreenBlockType = {}));
-const ScreenBlock = zod.z
+const ScreenBlock = z.z
     .object({
-    type: zod.z.enum(exports.ScreenBlockType),
+    type: z.z.enum(exports.ScreenBlockType),
 })
-    .and(zod.z.record(zod.z.string(), zod.z.any()));
+    .and(z.z.record(z.z.string(), z.z.any()));
 const BaseScreen = BaseWorkspaceElement.extend({
-    type: zod.z.enum(exports.ScreenType),
-    key: zod.z.string().optional(),
-    blocks: zod.z.array(ScreenBlock),
+    type: z.z.enum(exports.ScreenType),
+    key: z.z.string().optional(),
+    blocks: z.z.array(ScreenBlock),
 });
 
-const BaseCustomer = zod.z.object({
-    id: zod.z.string(),
-    name: zod.z.string(),
-    meta: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    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(),
-    createdAt: zod.z.string().optional(),
-    archivedAt: zod.z.string().optional(),
+const BaseCustomer = z.z.object({
+    id: z.z.string(),
+    name: z.z.string(),
+    meta: z.z.record(z.z.string(), z.z.any()).optional(),
+    internalId: z.z.string(),
+    fields: z.z.record(z.z.string(), z.z.any()).optional(),
+    credentials: z.z.any().optional(),
+    lastActiveAt: z.z.string().optional(),
+    isTest: z.z.boolean().optional(),
+    isBillable: z.z.boolean().optional(),
+    createdAt: z.z.string().optional(),
+    archivedAt: z.z.string().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(),
+    userId: z.z.string(),
+    connectionId: z.z.string().optional(),
+    flowId: z.z.string().optional(),
+    universalFlowId: z.z.string().optional(),
+    integrationId: z.z.string(),
+    instanceKey: z.z.string().optional(),
+    parameters: z.z.any().optional(),
     parametersSchema: DataSchema.optional(),
-    nodes: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    enabled: zod.z.boolean(),
-    createdAt: zod.z.string(),
-    updatedAt: zod.z.string(),
-    state: zod.z.enum(exports.WorkspaceElementState).optional(),
-    customized: zod.z
+    nodes: z.z.record(z.z.string(), z.z.any()).optional(),
+    enabled: z.z.boolean(),
+    createdAt: z.z.string(),
+    updatedAt: z.z.string(),
+    state: z.z.enum(exports.WorkspaceElementState).optional(),
+    customized: z.z
         .object({
-        name: zod.z.boolean().optional(),
-        nodes: zod.z.boolean().optional(),
+        name: z.z.boolean().optional(),
+        nodes: z.z.boolean().optional(),
     })
         .optional(),
-    dependencies: zod.z.array(zod.z.any()).optional(),
+    dependencies: z.z.array(z.z.any()).optional(),
 });
 exports.FlowInstanceNodeState = void 0;
 (function (FlowInstanceNodeState) {
@@ -9093,92 +9094,92 @@ exports.FlowInstanceNodeState = void 0;
     FlowInstanceNodeState["READY"] = "READY";
 })(exports.FlowInstanceNodeState || (exports.FlowInstanceNodeState = {}));
 const FlowInstanceNode = FlowNode.extend({
-    state: zod.z.enum(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(),
-    filter: zod.z.any().optional(),
-    name: zod.z.string().optional(),
-});
-const flowInstanceNodeCreateSchema = zod.z.object({
-    name: zod.z.string().optional(),
-    type: zod.z.string().optional(),
-    userConfig: zod.z.any().optional(),
-    config: zod.z.any().optional(),
-    onError: zod.z.enum(['stop', 'continue']).optional(),
-    concurrency: zod.z.number().optional(),
-    ui: zod.z.any().optional(),
-    links: zod.z.array(flowNodeLinkSchema).optional(),
-    isCustomized: zod.z.boolean().optional(),
-});
-const flowInstanceNodeUpdateSchema = zod.z.object({
-    name: zod.z.string().optional(),
-    type: zod.z.string().optional(),
-    userConfig: zod.z.any().optional(),
-    config: zod.z.any().optional(),
-    onError: zod.z.enum(['stop', 'continue']).optional(),
-    links: zod.z.array(flowNodeLinkSchema).optional(),
-    concurrency: zod.z.number().optional(),
-    isCustomized: zod.z.boolean().optional(),
-});
-const createFlowInstanceSchema = zod.z.object({
-    name: zod.z.string().optional(),
-    userId: zod.z.string().optional(),
-    flowId: zod.z.string().optional(),
-    connectionId: zod.z.string().optional(),
-    integrationId: zod.z.string().optional(),
-    instanceKey: zod.z.string().optional(),
-    parameters: zod.z.any().optional(),
-    nodes: zod.z.record(zod.z.string(), flowInstanceNodeCreateSchema).optional(),
-    enabled: zod.z.boolean().optional(),
-    customized: zod.z
+    state: z.z.enum(exports.FlowInstanceNodeState).optional(),
+    errors: z.z.array(ErrorDataSchema).optional(),
+    userConfig: z.z.any().optional(),
+    testInput: z.z.any().optional(),
+    dependencies: z.z.array(z.z.any()).optional(),
+});
+
+const flowNodeLinkSchema = z.z.object({
+    key: z.z.string().optional(),
+    filter: z.z.any().optional(),
+    name: z.z.string().optional(),
+});
+const flowInstanceNodeCreateSchema = z.z.object({
+    name: z.z.string().optional(),
+    type: z.z.string().optional(),
+    userConfig: z.z.any().optional(),
+    config: z.z.any().optional(),
+    onError: z.z.enum(['stop', 'continue']).optional(),
+    concurrency: z.z.number().optional(),
+    ui: z.z.any().optional(),
+    links: z.z.array(flowNodeLinkSchema).optional(),
+    isCustomized: z.z.boolean().optional(),
+});
+const flowInstanceNodeUpdateSchema = z.z.object({
+    name: z.z.string().optional(),
+    type: z.z.string().optional(),
+    userConfig: z.z.any().optional(),
+    config: z.z.any().optional(),
+    onError: z.z.enum(['stop', 'continue']).optional(),
+    links: z.z.array(flowNodeLinkSchema).optional(),
+    concurrency: z.z.number().optional(),
+    isCustomized: z.z.boolean().optional(),
+});
+const createFlowInstanceSchema = z.z.object({
+    name: z.z.string().optional(),
+    userId: z.z.string().optional(),
+    flowId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    instanceKey: z.z.string().optional(),
+    parameters: z.z.any().optional(),
+    nodes: z.z.record(z.z.string(), flowInstanceNodeCreateSchema).optional(),
+    enabled: z.z.boolean().optional(),
+    customized: z.z
         .object({
-        name: zod.z.boolean().optional(),
-        nodes: zod.z.boolean().optional(),
+        name: z.z.boolean().optional(),
+        nodes: z.z.boolean().optional(),
     })
         .optional(),
 });
-const updateFlowInstanceSchema = zod.z.object({
-    name: zod.z.string().optional(),
-    enabled: zod.z.boolean().optional(),
-    parameters: zod.z.any().optional(),
-    nodes: zod.z.record(zod.z.string(), flowInstanceNodeUpdateSchema).optional(),
-    archivedAt: zod.z.string().optional(),
-    customized: zod.z
+const updateFlowInstanceSchema = z.z.object({
+    name: z.z.string().optional(),
+    enabled: z.z.boolean().optional(),
+    parameters: z.z.any().optional(),
+    nodes: z.z.record(z.z.string(), flowInstanceNodeUpdateSchema).optional(),
+    archivedAt: z.z.string().optional(),
+    customized: z.z
         .object({
-        name: zod.z.boolean().optional(),
-        nodes: zod.z.boolean().optional(),
+        name: z.z.boolean().optional(),
+        nodes: z.z.boolean().optional(),
     })
         .optional(),
 });
 
 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(),
+    userId: z.z.string(),
+    revision: z.z.string(),
+    connectionId: z.z.string(),
+    integrationId: z.z.string(),
+    fieldMappingRevision: z.z.string().optional(),
+    fieldMappingId: z.z.string().optional(),
+    instanceKey: z.z.string().optional(),
+    dataSourceInstanceId: z.z.string().optional(),
     dataSourceSchema: DataSchema.optional(),
-    direction: zod.z.enum(exports.FieldMappingDirection).optional(),
+    direction: z.z.enum(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.enum(exports.WorkspaceElementState).optional(),
+    importValue: z.z.any().optional(),
+    exportValue: z.z.any().optional(),
+    isCustomized: z.z.boolean().optional(),
+    unifiedExportValue: z.z.any().optional(),
+    unifiedImportValue: z.z.any().optional(),
+    frozenImportFields: z.z.array(z.z.string()).optional(),
+    frozenExportFields: z.z.array(z.z.string()).optional(),
+    state: z.z.enum(exports.WorkspaceElementState).optional(),
     error: ErrorDataSchema.optional(),
-    externalSchema: zod.z.any().optional(),
+    externalSchema: z.z.any().optional(),
 });
 
 exports.DataLinkDirection = void 0;
@@ -9187,27 +9188,29 @@ exports.DataLinkDirection = void 0;
     DataLinkDirection["EXPORT"] = "export";
     DataLinkDirection["BOTH"] = "both";
 })(exports.DataLinkDirection || (exports.DataLinkDirection = {}));
-const BaseDataLinkTable = BaseMembraneInterface.extend({
-    archivedAt: zod.z.string().optional(),
-});
+const DataLinkTableSpecificProperties = z.z.object({});
+const DataLinkTableEditableProperties = BaseMembraneInterfaceEditableProperties.extend(DataLinkTableSpecificProperties.shape);
+const DataLinkTableExportProperties = BaseMembraneInterfaceEditableProperties.extend(DataLinkTableSpecificProperties.shape);
+const DataLinkTableReadOnlyProperties = BaseMembraneInterfaceReadOnlyProperties.extend({});
+const BaseDataLinkTable = BaseMembraneInterface.merge(DataLinkTableEditableProperties).merge(DataLinkTableReadOnlyProperties);
 
 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(),
+    dataLinkTableId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    integrationId: z.z.string(),
+    instanceKey: z.z.string().optional(),
+    userId: z.z.string(),
+    archivedAt: z.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.enum(exports.DataLinkDirection),
+const DataLink = z.z.object({
+    id: z.z.string(),
+    dataLinkTableInstanceId: z.z.string(),
+    externalRecordId: z.z.string(),
+    appRecordId: z.z.string(),
+    direction: z.z.enum(exports.DataLinkDirection),
 });
-const DataLinkTableConfig = zod.z.object({
-    key: zod.z.string(),
+const DataLinkTableConfig = z.z.object({
+    key: z.z.string(),
 });
 
 exports.HttpRequestMethod = void 0;
@@ -9218,12 +9221,12 @@ exports.HttpRequestMethod = void 0;
     HttpRequestMethod["PUT"] = "PUT";
     HttpRequestMethod["DELETE"] = "DELETE";
 })(exports.HttpRequestMethod || (exports.HttpRequestMethod = {}));
-const HttpRequestSpec = zod.z.object({
-    method: zod.z.string().toUpperCase().pipe(zod.z.enum(exports.HttpRequestMethod)).optional(),
-    uri: zod.z.any(),
-    headers: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    query: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    body: zod.z.any().optional(),
+const HttpRequestSpec = z.z.object({
+    method: z.z.string().toUpperCase().pipe(z.z.enum(exports.HttpRequestMethod)).optional(),
+    uri: z.z.any(),
+    headers: z.z.record(z.z.string(), z.z.any()).optional(),
+    query: z.z.record(z.z.string(), z.z.any()).optional(),
+    body: z.z.any().optional(),
 });
 const HTTP_REQUEST_SCHEMA = {
     type: 'object',
@@ -9248,45 +9251,59 @@ const HTTP_REQUEST_SCHEMA = {
 };
 
 const BaseAppEventType = BaseMembraneInterface.extend({
-    revision: zod.z.string(),
-    archivedAt: zod.z.string().optional(),
+    revision: z.z.string(),
+    archivedAt: z.z.string().optional(),
+    webhookKey: z.z.string(),
     subscribeRequest: HttpRequestSpec.optional(),
-    example: zod.z.any().optional(),
+    example: z.z.any().optional(),
+    schema: DataSchema.optional(),
+    globalWebhookUri: z.z.string(),
+    tenantIdFormula: z.z.any().optional(),
+    userIdFormula: z.z.any().optional(),
+});
+const AppEventTypeEditableProperties = BaseMembraneInterfaceEditableProperties.extend({
     schema: DataSchema.optional(),
-    globalWebhookUri: zod.z.string(),
-    tenantIdFormula: zod.z.any().optional(),
-    userIdFormula: zod.z.any().optional(),
+    example: z.z.any().optional(),
+    tenantIdFormula: z.z.any().optional(),
+    userIdFormula: z.z.any().optional(),
+    subscribeRequest: HttpRequestSpec.optional(),
 });
+const AppEventTypeExportProperties = BaseMembraneInterfaceEditableProperties.extend({});
 
 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(),
+    revision: z.z.string(),
+    appEventTypeId: z.z.string(),
+    userId: z.z.string(),
+    instanceKey: z.z.string().optional(),
+    isSubscribed: z.z.boolean(),
     schema: DataSchema.optional(),
-    webhookUri: zod.z.string(),
+    webhookUri: z.z.string(),
     subscriptionRequest: HttpRequestSpec,
-    subscriptionResponse: zod.z.any().optional(),
-    archivedAt: zod.z.string().optional(),
+    subscriptionResponse: z.z.any().optional(),
+    archivedAt: z.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(),
+    schema: z.z.any(),
+    code: z.z.string().optional(),
+    archivedAt: z.z.string().optional(),
+    revision: z.z.string().optional(),
+});
+const AppDataSchemaEditableProperties = BaseMembraneInterfaceEditableProperties.extend({
+    schema: z.z.any(),
+    code: z.z.string().optional(),
 });
+const AppDataSchemaExportProperties = AppDataSchemaEditableProperties.extend({});
 
 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(),
+    appId: z.z.string(),
+    userId: z.z.string(),
+    appDataSchemaId: z.z.string(),
+    appDataSchemaRevision: z.z.string(),
+    instanceKey: z.z.string().optional(),
+    schema: z.z.any().optional(),
     error: ErrorDataSchema.optional(),
-    archivedAt: zod.z.string().optional(),
+    archivedAt: z.z.string().optional(),
 });
 
 exports.ExternalEventSubscriptionStatus = void 0;
@@ -9302,33 +9319,33 @@ 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.enum(exports.ExternalEventSubscriptionType),
+const ExternalEventSubscriptionConfig = z.z.object({
+    type: z.z.enum(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(),
+    eventKey: z.z.string().optional(),
+    eventParameters: z.z.any().optional(),
+});
+const BaseExternalEventSubscription = z.z.object({
+    id: z.z.string(),
+    name: z.z.string().optional(),
+    userId: z.z.string(),
+    connectionId: z.z.string(),
+    integrationId: z.z.string(),
     config: ExternalEventSubscriptionConfig.optional(),
-    status: zod.z.enum(exports.ExternalEventSubscriptionStatus).optional(),
+    status: z.z.enum(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(),
+    isRealTime: z.z.boolean().optional(),
+    requiresPull: z.z.boolean().optional(),
+    requiresFullSync: z.z.boolean().optional(),
+    createdAt: z.z.string().optional(),
+    archivedAt: z.z.string().optional(),
+    stateData: z.z.any().optional(),
+    nextPullEventsTimestamp: z.z.number().optional(),
+    pullUpdatesIntervalSeconds: z.z.number().optional(),
+    fullSyncIntervalSeconds: z.z.number().optional(),
+    nextRefreshTimestamp: z.z.number().optional(),
+    globalWebhookKey: z.z.string().optional(),
+    globalWebhookEventSelector: z.z.string().optional(),
 });
 
 exports.ExternalEventLogStatus = void 0;
@@ -9337,16 +9354,16 @@ 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.enum(exports.ExternalEventLogStatus),
+const BaseExternalEventLogRecord = z.z.object({
+    id: z.z.string(),
+    userId: z.z.string(),
+    name: z.z.string().optional(),
+    externalEventSubscriptionId: z.z.string(),
+    integrationId: z.z.string(),
+    connectionId: z.z.string(),
+    payload: z.z.any().optional(),
+    launchedFlowRunIds: z.z.array(z.z.string()).optional(),
+    status: z.z.enum(exports.ExternalEventLogStatus),
     error: ErrorDataSchema.optional(),
 });
 
@@ -9357,18 +9374,18 @@ exports.ExternalEventPullStatus = void 0;
     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.enum(exports.ExternalEventPullStatus),
-    collectedEventIds: zod.z.array(zod.z.string()),
+const BaseExternalEventPull = z.z.object({
+    id: z.z.string(),
+    name: z.z.string().optional(),
+    userId: z.z.string(),
+    externalEventSubscriptionId: z.z.string(),
+    integrationId: z.z.string(),
+    connectionId: z.z.string(),
+    startDatetime: z.z.string(),
+    endDatetime: z.z.string(),
+    isFullScan: z.z.boolean().optional(),
+    status: z.z.enum(exports.ExternalEventPullStatus),
+    collectedEventIds: z.z.array(z.z.string()),
     error: ErrorDataSchema.optional(),
 });
 
@@ -9378,17 +9395,17 @@ exports.ActionRunLogStatus = void 0;
     ActionRunLogStatus["ERROR"] = "error";
 })(exports.ActionRunLogStatus || (exports.ActionRunLogStatus = {}));
 const BaseActionRunLogRecord = BaseWorkspaceElement.extend({
-    actionId: zod.z.string(),
-    actionInstanceId: zod.z.string(),
-    integrationId: zod.z.string(),
-    connectionId: zod.z.string(),
-    input: zod.z.any().optional(),
-    output: zod.z.any().optional(),
-    status: zod.z.enum(exports.ActionRunLogStatus),
-    createdAt: zod.z.string(),
-    completedAt: zod.z.string().optional(),
+    actionId: z.z.string(),
+    actionInstanceId: z.z.string(),
+    integrationId: z.z.string(),
+    connectionId: z.z.string(),
+    input: z.z.any().optional(),
+    output: z.z.any().optional(),
+    status: z.z.enum(exports.ActionRunLogStatus),
+    createdAt: z.z.string(),
+    completedAt: z.z.string().optional(),
     error: ErrorDataSchema.optional(),
-    duration: zod.z.number().optional(),
+    duration: z.z.number().optional(),
 });
 
 const ActionApiResponse = BaseAction.extend({
@@ -9399,19 +9416,19 @@ const ActionApiResponse = BaseAction.extend({
     defaultOutputSchema: DataSchema.optional(),
     transformedOutputSchema: DataSchema.optional(),
     outputSchema: DataSchema.optional(),
-    dependencies: zod.z.array(zod.z.any()).optional(),
+    dependencies: z.z.array(z.z.any()).optional(),
 });
 const FindActionsQuery = FindIntegrationLevelMembraneInterfaceQuery;
 const CreateActionRequest = ActionEditableProperties;
 const UpdateActionRequest = CreateActionRequest.extend({}).partial();
 const CreateActionInstanceRequest = CreateActionRequest;
 const UpdateActionInstanceRequest = UpdateActionRequest;
-const RunActionRequest = zod.z.object({
-    input: zod.z.any().optional(),
+const RunActionRequest = z.z.object({
+    input: z.z.any().optional(),
 });
-const ActionRunResponse = zod.z.object({
-    output: zod.z.any().optional(),
-    logs: zod.z.array(zod.z.any()).optional(),
+const ActionRunResponse = z.z.object({
+    output: z.z.any().optional(),
+    logs: z.z.array(z.z.any()).optional(),
 });
 const ActionInstanceApiResponse = ActionApiResponse;
 const ListActionInstancesForConnectionQuery = FindActionsQuery;
@@ -9423,54 +9440,54 @@ const ActionRunLogRecordApiResponse = BaseActionRunLogRecord.extend({
     connection: BaseConnection.optional(),
 });
 
-const FindConnectionsQuery = zod.z
+const FindConnectionsQuery = z.z
     .object({
-    userId: zod.z.string().optional(),
+    userId: z.z.string().optional(),
     isTest: zodBooleanCoercion().optional(),
-    integrationKey: zod.z.string().optional(),
-    integrationId: zod.z.string().optional(),
+    integrationKey: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
     includeArchived: zodBooleanCoercion().optional(),
 })
     .merge(PaginationQuery);
-const CreateConnectionRequest = zod.z.object({
-    name: zod.z.string(),
-    integrationId: zod.z.string(),
-    credentials: zod.z.string().optional(),
+const CreateConnectionRequest = z.z.object({
+    name: z.z.string(),
+    integrationId: z.z.string(),
+    credentials: z.z.string().optional(),
 });
-const UpdateConnectionRequest = zod.z.object({
-    name: zod.z.string().optional(),
-    credentials: zod.z.string().optional(),
-    accessToken: zod.z.string().optional(),
+const UpdateConnectionRequest = z.z.object({
+    name: z.z.string().optional(),
+    credentials: z.z.string().optional(),
+    accessToken: z.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 ConnectionSelector = z.z.object({
+    id: z.z.string().optional(),
+    integrationKey: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
 });
 const ConnectionApiResponse = BaseConnection.extend({
     user: BaseCustomer.optional(),
     integration: BaseIntegration.optional(),
 });
 const ConnectionApiResponseWithSecrets = ConnectionApiResponse.extend({
-    credentials: zod.z.unknown().optional(),
-    parameters: zod.z.unknown().optional(),
-    connectorParameters: zod.z.unknown().optional(),
-});
-const ConnectionMessagePayload = zod.z.discriminatedUnion('type', [
-    zod.z.object({
-        source: zod.z.string(),
-        requestId: zod.z.string(),
-        type: zod.z.literal('newConnectionCreated'),
+    credentials: z.z.unknown().optional(),
+    parameters: z.z.unknown().optional(),
+    connectorParameters: z.z.unknown().optional(),
+});
+const ConnectionMessagePayload = z.z.discriminatedUnion('type', [
+    z.z.object({
+        source: z.z.string(),
+        requestId: z.z.string(),
+        type: z.z.literal('newConnectionCreated'),
         connection: ConnectionApiResponse,
     }),
-    zod.z.object({
-        source: zod.z.string(),
-        requestId: zod.z.string(),
-        type: zod.z.literal('newConnectionFailure'),
-        error: zod.z.string(),
+    z.z.object({
+        source: z.z.string(),
+        requestId: z.z.string(),
+        type: z.z.literal('newConnectionFailure'),
+        error: z.z.string(),
         errorData: ErrorDataSchema.optional(),
     }),
 ]);
@@ -9478,72 +9495,72 @@ const ConnectionMessagePayload = zod.z.discriminatedUnion('type', [
 const DataSourceApiResponse = BaseDataSource.extend({
     integration: BaseIntegration.optional(),
     appliedToIntegrations: AppliedToIntegrations(BaseDataSource).optional(),
-    defaultPath: zod.z.string().optional().meta({ deprecated: true }),
+    defaultPath: z.z.string().optional().meta({ deprecated: true }),
 });
 const FindDataSourcesQuery = FindIntegrationLevelMembraneInterfaceQuery.omit({ parentId: true }).extend({
-    dataSourceId: zod.z.string().optional(),
-    universalDataSourceId: zod.z.string().optional(),
+    dataSourceId: z.z.string().optional(),
+    universalDataSourceId: z.z.string().optional(),
 });
 const CreateDataSourceRequest = DataSourceEditableProperties;
 const UpdateDataSourceRequest = CreateDataSourceRequest.extend({}).partial();
-const FindDataSourceInstancesQuery = zod.z
+const FindDataSourceInstancesQuery = z.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(),
+    userId: z.z.string().optional(),
+    dataSourceId: z.z.string().optional(),
+    universalDataSourceId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    integrationKey: z.z.string().optional(),
+    integrationId: z.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
+const CreateDataSourceInstanceRequest = z.z.object({
+    dataSourceId: z.z.string(),
+    connectionId: z.z.string(),
+    path: z.z.string().optional(),
+});
+const UpdateDataSourceInstanceRequest = z.z.object({
+    path: z.z.string().optional(),
+    collectionKey: z.z.string().optional(),
+    collectionParameters: z.z.any().optional(),
+    pullUpdatesIntervalSeconds: z.z.number().optional(),
+    fullSyncIntervalSeconds: z.z.number().optional(),
+    subscribedTo: z.z
         .object({
-        created: zod.z.boolean().optional(),
-        updated: zod.z.boolean().optional(),
-        deleted: zod.z.boolean().optional(),
+        created: z.z.boolean().optional(),
+        updated: z.z.boolean().optional(),
+        deleted: z.z.boolean().optional(),
     })
         .optional(),
 });
-const FindDataSourceEventsQuery = zod.z
+const FindDataSourceEventsQuery = z.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(),
+    userId: z.z.string().optional(),
+    udm: z.z.string().optional(),
+    dataSourceInstanceId: z.z.string().optional(),
+    startDatetime: z.z.string().optional(),
+    endDatetime: z.z.string().optional(),
 })
     .merge(PaginationQuery);
-const FindDataSourceSyncsQuery = zod.z
+const FindDataSourceSyncsQuery = z.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(),
+    userId: z.z.string().optional(),
+    dataSourceId: z.z.string().optional(),
+    dataSourceInstanceId: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    startedAfter: z.z.string().optional(),
 })
     .merge(PaginationQuery);
-const ListDataSourceInstancesForConnectionQuery = zod.z
+const ListDataSourceInstancesForConnectionQuery = z.z
     .object({
-    dataSourceId: zod.z.string().optional(),
+    dataSourceId: z.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(),
+    userId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    dataSourceInstanceId: z.z.string().optional(),
 });
 
 const DataSourceInstanceApiResponse = BaseDataSourceInstance.extend({
@@ -9551,8 +9568,8 @@ const DataSourceInstanceApiResponse = BaseDataSourceInstance.extend({
     dataSource: BaseDataSource.optional(),
     connection: BaseConnection.optional(),
     integration: BaseIntegration.optional(),
-    path: zod.z.string().optional().meta({ deprecated: true }),
-    defaultPath: zod.z.string().optional().meta({ deprecated: true }),
+    path: z.z.string().optional().meta({ deprecated: true }),
+    defaultPath: z.z.string().optional().meta({ deprecated: true }),
 });
 
 const ExternalEvent = BaseExternalEvent.extend({
@@ -9562,64 +9579,64 @@ const ExternalEvent = BaseExternalEvent.extend({
 const FlowApiResponse = BaseFlow.extend({
     integration: BaseIntegration.optional(),
     appliedToIntegrations: AppliedToIntegrations(BaseFlow).optional(),
-    dependencies: zod.z.array(zod.z.any()).optional(),
+    dependencies: z.z.array(z.z.any()).optional(),
 });
 const FindFlowsQuery = FindIntegrationLevelMembraneInterfaceQuery.omit({ parentId: true }).extend({
-    flowId: zod.z.string().optional(),
-    universalFlowId: zod.z.string().optional(),
+    flowId: z.z.string().optional(),
+    universalFlowId: z.z.string().optional(),
 });
 const CreateFlowRequest = FlowEditableProperties;
 const UpdateFlowRequest = CreateFlowRequest.extend({}).partial();
-const ListFlowInstancesForConnectionQuery = zod.z
+const ListFlowInstancesForConnectionQuery = z.z
     .object({
-    flowId: zod.z.string().optional(),
-    flowKey: zod.z.string().optional(),
-    enabled: zod.z.boolean().optional(),
+    flowId: z.z.string().optional(),
+    flowKey: z.z.string().optional(),
+    enabled: z.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 ResetFlowInstanceOptions = z.z.object({
+    name: z.z.boolean().optional(),
+    nodes: z.z.record(z.z.string(), z.z.boolean()).optional(),
+    allNodes: z.z.boolean().optional(),
 });
-const RunFlowApiRequest = zod.z.object({
-    nodeKey: zod.z.string().optional(),
-    input: zod.z.any().optional(),
+const RunFlowApiRequest = z.z.object({
+    nodeKey: z.z.string().optional(),
+    input: z.z.any().optional(),
 });
 const FlowInstanceApiResponse = BaseFlowInstance.extend({
-    user: zod.z.lazy(() => zod.z.any()).optional(),
-    connection: zod.z.lazy(() => zod.z.any()).optional(),
-    flow: zod.z.lazy(() => FlowApiResponse).optional(),
-    integration: zod.z.lazy(() => zod.z.any()).optional(),
+    user: z.z.lazy(() => z.z.any()).optional(),
+    connection: z.z.lazy(() => z.z.any()).optional(),
+    flow: z.z.lazy(() => FlowApiResponse).optional(),
+    integration: z.z.lazy(() => z.z.any()).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 CreateFlowNodeRequest = z.z.object({
+    type: z.z.string(),
+    config: z.z.any().optional(),
+    ui: z.z.any().optional(),
+    links: z.z.array(z.z.lazy(() => z.z.any())).optional(),
 });
 
-const CreateFlowRunRequest = zod.z.object({
-    flowInstanceId: zod.z.string(),
-    nodeKey: zod.z.string().optional(),
-    input: zod.z.any().optional(),
+const CreateFlowRunRequest = z.z.object({
+    flowInstanceId: z.z.string(),
+    nodeKey: z.z.string().optional(),
+    input: z.z.any().optional(),
 });
 const FindFlowRunsQuery = PaginationQuery.extend({
-    id: zod.z.string().optional(),
-    flowInstanceId: zod.z.string().optional(),
-    startNodeKey: zod.z.string().optional(),
-    flowId: zod.z.string().optional(),
-    universalFlowId: zod.z.string().optional(),
-    userId: zod.z.string().optional(),
-    state: zod.z.enum(exports.FlowRunState).optional(),
-    integrationId: zod.z.string().optional(),
-    connectionId: zod.z.string().optional(),
-    startedAfter: zod.z.string().optional(),
-});
-const FlowRunLaunchedByApi = zod.z.object({
-    type: zod.z.enum(exports.FlowRunLaunchedByTrigger),
-    ids: zod.z.array(zod.z.string()).optional(),
+    id: z.z.string().optional(),
+    flowInstanceId: z.z.string().optional(),
+    startNodeKey: z.z.string().optional(),
+    flowId: z.z.string().optional(),
+    universalFlowId: z.z.string().optional(),
+    userId: z.z.string().optional(),
+    state: z.z.enum(exports.FlowRunState).optional(),
+    integrationId: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    startedAfter: z.z.string().optional(),
+});
+const FlowRunLaunchedByApi = z.z.object({
+    type: z.z.enum(exports.FlowRunLaunchedByTrigger),
+    ids: z.z.array(z.z.string()).optional(),
 });
 const FlowRunApiResponse = BaseFlowRun.extend({
     flowInstance: BaseFlowInstance.optional(),
@@ -9627,46 +9644,46 @@ const FlowRunApiResponse = BaseFlowRun.extend({
     integration: BaseIntegration.optional(),
     user: BaseCustomer.optional(),
 });
-const FindFlowRunsResponse = zod.z.object({
-    items: zod.z.array(FlowRunApiResponse),
-    cursor: zod.z.string().optional(),
-});
-
-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 IntegrationAuthUi = zod.z.object({
-    schema: zod.z.any().optional(),
-    helpUri: zod.z.string().optional(),
-});
-const IntegrationAuthOption = zod.z.object({
-    key: zod.z.string(),
-    type: zod.z.enum(CONNECTOR_AUTH_TYPES),
-    title: zod.z.string().optional(),
-    description: zod.z.string().optional(),
+const FindFlowRunsResponse = z.z.object({
+    items: z.z.array(FlowRunApiResponse),
+    cursor: z.z.string().optional(),
+});
+
+const CreateIntegrationRequest = z.z.object({
+    name: z.z.string().optional(),
+    key: z.z.string(),
+    baseUri: z.z.string(),
+    logoUri: z.z.string(),
+});
+const UpdateIntegrationRequest = z.z.object({
+    name: z.z.string().optional(),
+    key: z.z.string().optional(),
+    baseUri: z.z.string().optional(),
+    logoUri: z.z.string().optional(),
+});
+const FindIntegrationsQuery = z.z.object({}).merge(PaginationQuery).merge(SearchQuery);
+const IntegrationAuthUi = z.z.object({
+    schema: z.z.any().optional(),
+    helpUri: z.z.string().optional(),
+});
+const IntegrationAuthOption = z.z.object({
+    key: z.z.string(),
+    type: z.z.enum(CONNECTOR_AUTH_TYPES),
+    title: z.z.string().optional(),
+    description: z.z.string().optional(),
     ui: IntegrationAuthUi.optional(),
 });
 const IntegrationApiResponse = BaseIntegration.extend({
     connection: BaseConnection.optional(),
-    spec: zod.z.any().optional(),
-    authOptions: zod.z.array(IntegrationAuthOption).optional(),
+    spec: z.z.any().optional(),
+    authOptions: z.z.array(IntegrationAuthOption).optional(),
     parametersSchema: DataSchema.optional(),
 });
 
-const PackageElementApi = zod.z.object({
-    id: zod.z.string(),
-    type: zod.z.enum(exports.IntegrationElementType),
-    element: zod.z.any().optional(),
+const PackageElementApi = z.z.object({
+    id: z.z.string(),
+    type: z.z.enum(exports.IntegrationElementType),
+    element: z.z.any().optional(),
 });
 const FindPackagesQuery = FindIntegrationLevelMembraneInterfaceQuery;
 const CreatePackageRequest = PackageEditableProperties;
@@ -9677,25 +9694,25 @@ const PackageApiResponse = BasePackage.extend({
 
 const ScreenApiResponse = BaseScreen;
 
-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 CreateCustomerRequest = z.z.object({
+    name: z.z.string().optional(),
+    internalId: z.z.string(),
+    fields: z.z.any().optional(),
+    credentials: z.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 UpdateCustomerRequest = z.z.object({
+    name: z.z.string().optional(),
+    internalId: z.z.string().optional(),
+    fields: z.z.any().optional(),
+    credentials: z.z.any().optional(),
 });
-const FindCustomersQuery = zod.z
+const FindCustomersQuery = z.z
     .object({
     isTest: zodBooleanCoercion().optional(),
 })
     .merge(PaginationQuery)
     .merge(SearchQuery);
-const CustomerSelector = zod.z.object({ id: zod.z.string() });
+const CustomerSelector = z.z.object({ id: z.z.string() });
 const CustomerApiResponse = BaseCustomer;
 
 const FieldMappingApiResponse = BaseFieldMapping.extend({
@@ -9703,8 +9720,8 @@ const FieldMappingApiResponse = BaseFieldMapping.extend({
     appliedToIntegrations: AppliedToIntegrations(BaseFieldMapping).optional(),
 });
 const FindFieldMappingsQuery = FindIntegrationLevelMembraneInterfaceQuery.omit({ parentId: true }).extend({
-    fieldMappingId: zod.z.string().optional(),
-    universalFieldMappingId: zod.z.string().optional(),
+    fieldMappingId: z.z.string().optional(),
+    universalFieldMappingId: z.z.string().optional(),
 });
 const CreateFieldMappingRequest = FieldMappingEditableProperties;
 const UpdateFieldMappingRequest = CreateFieldMappingRequest.extend({}).partial();
@@ -9717,6 +9734,9 @@ const FieldMappingInstanceApiResponse = BaseFieldMappingInstance.extend({
     dataSourceInstance: DataSourceInstanceApiResponse.optional(),
 });
 
+const FindDataLinkTablesQuery = z.z.object(CommonListElementsQuery.shape);
+const CreateDataLinkTableRequest = DataLinkTableEditableProperties;
+const UpdateDataLinkTableRequest = CreateDataLinkTableRequest.partial();
 const DataLinkTableApiResponse = BaseDataLinkTable;
 
 const DataLinkTableInstanceApiResponse = BaseDataLinkTableInstance.extend({
@@ -9741,10 +9761,10 @@ const AppDataSchemaInstanceApiResponse = BaseAppDataSchemaInstance.extend({
 });
 
 const ListExternalEventLogRecordsQuery = CommonListElementsQuery.extend({
-    connectionId: zod.z.string().optional(),
-    integrationId: zod.z.string().optional(),
-    externalEventSubscriptionId: zod.z.string().optional(),
-    status: zod.z.enum(exports.ExternalEventLogStatus).optional(),
+    connectionId: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    externalEventSubscriptionId: z.z.string().optional(),
+    status: z.z.enum(exports.ExternalEventLogStatus).optional(),
 });
 const ExternalEventLogRecordApiResponse = BaseExternalEventLogRecord.extend({
     user: BaseCustomer.optional(),
@@ -9754,10 +9774,10 @@ const ExternalEventLogRecordApiResponse = BaseExternalEventLogRecord.extend({
 });
 
 const ListExternalEventPullsQuery = CommonListElementsQuery.extend({
-    connectionId: zod.z.string().optional(),
-    integrationId: zod.z.string().optional(),
-    externalEventSubscriptionId: zod.z.string().optional(),
-    status: zod.z.enum(exports.ExternalEventPullStatus).optional(),
+    connectionId: z.z.string().optional(),
+    integrationId: z.z.string().optional(),
+    externalEventSubscriptionId: z.z.string().optional(),
+    status: z.z.enum(exports.ExternalEventPullStatus).optional(),
 });
 const ExternalEventPullApiResponse = BaseExternalEventPull.extend({
     user: BaseCustomer.optional(),
@@ -9772,18 +9792,18 @@ const ExternalEventSubscriptionApiResponse = BaseExternalEventSubscription.exten
     integration: BaseIntegration.optional(),
 });
 
-const AppEventLogRecordApiResponse = zod.z.object({
-    id: zod.z.string(),
-    name: zod.z.string().optional(),
-    userId: zod.z.string(),
+const AppEventLogRecordApiResponse = z.z.object({
+    id: z.z.string(),
+    name: z.z.string().optional(),
+    userId: z.z.string(),
     user: BaseCustomer.optional(),
-    appEventTypeId: zod.z.string(),
+    appEventTypeId: z.z.string(),
     appEventType: BaseAppEventType.optional(),
-    appEventSubscriptionId: zod.z.string(),
+    appEventSubscriptionId: z.z.string(),
     appEventSubscription: BaseAppEventSubscription.optional(),
-    event: zod.z.any(),
-    datetime: zod.z.string(),
-    launchedFlowRunIds: zod.z.array(zod.z.string()),
+    event: z.z.any(),
+    datetime: z.z.string(),
+    launchedFlowRunIds: z.z.array(z.z.string()),
 });
 
 class DependencyError extends MembraneError {
@@ -9925,71 +9945,6 @@ function hasCycles(nodes) {
     return hasCycles;
 }
 
-exports.WorkspaceElementChangeType = void 0;
-(function (WorkspaceElementChangeType) {
-    WorkspaceElementChangeType["CREATE"] = "create";
-    WorkspaceElementChangeType["UPDATE"] = "update";
-    WorkspaceElementChangeType["DELETE"] = "delete";
-})(exports.WorkspaceElementChangeType || (exports.WorkspaceElementChangeType = {}));
-function compareWorkspaceExports(primaryExport, targetExport) {
-    const changes = [];
-    const result = {
-        [exports.WorkspaceElementChangeType.CREATE]: new Set(),
-        [exports.WorkspaceElementChangeType.UPDATE]: new Set(),
-        [exports.WorkspaceElementChangeType.DELETE]: new Set(),
-    };
-    const primaryMap = new Map();
-    const otherMap = new Map();
-    const typeMap = new Map();
-    const allElementTypes = new Set([...Object.keys(primaryExport), ...Object.keys(targetExport)]);
-    for (const elementType of allElementTypes) {
-        const type = elementType;
-        const primaryElements = primaryExport[type] || [];
-        for (const element of primaryElements) {
-            primaryMap.set(element.uuid, element);
-            typeMap.set(element.uuid, type);
-        }
-        const otherElements = targetExport[type] || [];
-        for (const element of otherElements) {
-            otherMap.set(element.uuid, element);
-            typeMap.set(element.uuid, type);
-        }
-    }
-    for (const [uuid] of typeMap) {
-        const primaryElement = primaryMap.get(uuid);
-        const otherElement = otherMap.get(uuid);
-        const change = compareElementExports(primaryElement, otherElement);
-        if (change) {
-            changes.push(change);
-        }
-    }
-    changes.forEach((change) => {
-        result[change.type].add(change.uuid);
-    });
-    return result;
-}
-function compareElementExports(primaryElement, targetElement) {
-    if (primaryElement && !targetElement) {
-        return {
-            type: exports.WorkspaceElementChangeType.CREATE,
-            uuid: primaryElement.uuid,
-        };
-    }
-    if (!primaryElement && targetElement) {
-        return {
-            type: exports.WorkspaceElementChangeType.DELETE,
-            uuid: targetElement.uuid,
-        };
-    }
-    if (primaryElement && targetElement && !deepEqual(primaryElement, targetElement)) {
-        return {
-            type: exports.WorkspaceElementChangeType.UPDATE,
-            uuid: primaryElement.uuid,
-        };
-    }
-    return undefined;
-}
-
 const WorkspaceElementSpecs = {
     [exports.WorkspaceElementType.Customer]: {
         type: exports.WorkspaceElementType.Customer,
@@ -10139,6 +10094,10 @@ const WorkspaceElementSpecs = {
         apiPath: 'data-link-tables',
         name: 'Data Link Table',
         namePlural: 'Data Link Tables',
+        editablePropertiesSchema: DataLinkTableEditableProperties,
+        exportPropertiesSchema: DataLinkTableExportProperties,
+        apiResponseSchema: DataLinkTableApiResponse,
+        findQuerySchema: FindDataLinkTablesQuery,
         isMembraneInterface: true,
     },
     [exports.WorkspaceElementType.DataLinkTableInstance]: {
@@ -10155,6 +10114,8 @@ const WorkspaceElementSpecs = {
         name: 'App Event Type',
         namePlural: 'App Event Types',
         isMembraneInterface: true,
+        exportPropertiesSchema: AppEventTypeExportProperties,
+        editablePropertiesSchema: AppEventTypeEditableProperties,
     },
     [exports.WorkspaceElementType.AppEventSubscription]: {
         type: exports.WorkspaceElementType.AppEventSubscription,
@@ -10175,6 +10136,8 @@ const WorkspaceElementSpecs = {
         name: 'App Data Schema',
         namePlural: 'App Data Schemas',
         isMembraneInterface: true,
+        exportPropertiesSchema: AppDataSchemaExportProperties,
+        editablePropertiesSchema: AppDataSchemaEditableProperties,
     },
     [exports.WorkspaceElementType.AppDataSchemaInstance]: {
         type: exports.WorkspaceElementType.AppDataSchemaInstance,
@@ -10401,7 +10364,7 @@ function extractMembraneErrorData(error) {
             },
         };
     }
-    if (error instanceof zod.ZodError) {
+    if (error instanceof z.ZodError) {
         data.message = v4.fromError(error).toString();
     }
     return data;
@@ -10644,6 +10607,11 @@ function getFlowRunVariableSchema() {
     };
 }
 
+exports.WorkspaceType = void 0;
+(function (WorkspaceType) {
+    WorkspaceType["PRODUCTION"] = "production";
+    WorkspaceType["DEVELOPMENT"] = "development";
+})(exports.WorkspaceType || (exports.WorkspaceType = {}));
 exports.WorkspaceOnboardingStep = void 0;
 (function (WorkspaceOnboardingStep) {
     WorkspaceOnboardingStep["AddConnectors"] = "add-connectors";
@@ -10663,11 +10631,83 @@ exports.LimitUnits = void 0;
     LimitUnits["Msec"] = "msec";
     LimitUnits["Mb"] = "Mb";
 })(exports.LimitUnits || (exports.LimitUnits = {}));
-exports.WorkspaceType = void 0;
-(function (WorkspaceType) {
-    WorkspaceType["PRODUCTION"] = "production";
-    WorkspaceType["DEVELOPMENT"] = "development";
-})(exports.WorkspaceType || (exports.WorkspaceType = {}));
+const WorkspaceLimit = z.object({
+    value: z.number().optional(),
+    defaultValue: z.number().optional(),
+    unit: z.nativeEnum(exports.LimitUnits),
+});
+const WorkspaceLimitsSchema = z.object({
+    parallelEventPulls: WorkspaceLimit.optional(),
+    parallelIncrementalEventPullsPerConnection: WorkspaceLimit.optional(),
+    parallelFullSyncEventPullsPerConnection: WorkspaceLimit.optional(),
+    parallelFlowRuns: WorkspaceLimit.optional(),
+    parallelFlowRunsPerConnection: WorkspaceLimit.optional(),
+    parallelApiRequests: WorkspaceLimit.optional(),
+    parallelSseRequests: WorkspaceLimit.optional(),
+    parallelBackgroundJobs: WorkspaceLimit.optional(),
+    parallelEventLogs: WorkspaceLimit.optional(),
+    parallelEventLogsPerConnection: WorkspaceLimit.optional(),
+    ParallelWriteDatabaseRequests: WorkspaceLimit.optional(),
+    fileUploadsMbPerHour: WorkspaceLimit.optional(),
+    apiRequestsPerSecond: WorkspaceLimit.optional(),
+    apiRequestsPerHour: WorkspaceLimit.optional(),
+    webhookRequestsPerSecond: WorkspaceLimit.optional(),
+    webhookRequestsPerHour: WorkspaceLimit.optional(),
+    workspaceElementCreationsPerSecond: WorkspaceLimit.optional(),
+    workspaceElementCreationsPerHour: WorkspaceLimit.optional(),
+    createDatabaseRequestsPerSecond: WorkspaceLimit.optional(),
+    totalNumberOfCustomers: WorkspaceLimit.optional(),
+    totalNumberOfConnections: WorkspaceLimit.optional(),
+    totalNumberOfWorkspaceElements: WorkspaceLimit.optional(),
+    parallelApiRequestsPerCustomer: WorkspaceLimit.optional(),
+    parallelBackgroundJobsPerCustomer: WorkspaceLimit.optional(),
+    apiRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    apiRequestsPerCustomerPerHour: WorkspaceLimit.optional(),
+    webhookRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    webhookRequestsPerCustomerPerHour: WorkspaceLimit.optional(),
+    externalEventsPerCustomerPerDay: WorkspaceLimit.optional(),
+    createDatabaseRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    updateDatabaseRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    parallelWriteDatabaseRequestsPerCustomer: WorkspaceLimit.optional(),
+});
+const EngineWorkspaceSettingsSchema = z.object({
+    enableApiLogs: z.boolean().optional(),
+    enableWebhookLogs: z.boolean().optional(),
+    enableActionRunLogs: z.boolean().optional(),
+    disableSecretKeyAuth: z.boolean().optional(),
+});
+const WorkspacePublicKey = z.object({
+    name: z.string(),
+    publicKey: z.string(),
+});
+const AppSchema = z.object({
+    id: z.string(),
+    key: z.string(),
+    logoUri: z.string().optional(),
+    userFieldsSchema: z.any().optional(),
+    apiBaseUri: z.string().optional(),
+    webhookUri: z.string().optional(),
+    publicKey: z.string().optional(),
+    publicKeys: z.array(WorkspacePublicKey).optional(),
+    enabledWebhookEvents: z.array(z.string()).optional(),
+    auth: z.any().optional(),
+    credentialsSchema: z.any().optional(),
+    apiClient: z.any().optional(),
+    apiRequestHeaders: z.record(z.string(), z.any()).optional(),
+    apiRequestQuery: z.record(z.string(), z.any()).optional(),
+    isOnPrem: z.boolean().optional(),
+    connectorBaseUri: z.string().optional(),
+    connectorRevision: z.string().optional(),
+    featureFlags: z.array(z.string()).optional(),
+    limits: WorkspaceLimitsSchema.optional(),
+    settings: EngineWorkspaceSettingsSchema.optional(),
+    type: z.nativeEnum(exports.WorkspaceType).optional(),
+    jwksUri: z.string().nullable().optional(),
+    isTrial: z.boolean().optional(),
+    isThrottled: z.boolean().optional(),
+    isDisabled: z.boolean().optional(),
+    isBackgroundJobsDisabled: z.boolean().optional(),
+});
 
 const PARALLEL_EXECUTION_LIMITS = [
     'parallelEventPulls',
@@ -10706,129 +10746,153 @@ const EDITABLE_LIMITS = [
     'parallelFlowRunsPerConnection',
 ];
 
-const OrgWorkspaceSchema = zod.z.object({
-    id: zod.z.string(),
-    name: zod.z.string(),
-    orgId: zod.z.string(),
-    apiBaseUri: zod.z.string().optional(),
-    key: zod.z.string(),
-    secret: zod.z.string(),
-    createdAt: zod.z.coerce.date(),
-    updatedAt: zod.z.coerce.date(),
-    engineAccessToken: zod.z.string().optional(),
-    onboardingStep: zod.z.nativeEnum(exports.WorkspaceOnboardingStep).optional(),
-    trialEndDate: zod.z.string().optional(),
-    featureFlags: zod.z.array(zod.z.string()).optional(),
-    logoUri: zod.z.string().optional(),
-});
-const OrgWorkspaceUser = zod.z.object({
-    id: zod.z.string(),
-    workspaceId: zod.z.string(),
-    testCustomerId: zod.z.string(),
-    userId: zod.z.string(),
-    role: zod.z.string(),
-});
-
-const WorkspaceLimit = zod.z.object({
-    value: zod.z.number().optional(),
-    defaultValue: zod.z.number().optional(),
-    unit: zod.z.nativeEnum(exports.LimitUnits),
-});
-const WorkspaceLimitsSchema = zod.z.object({
-    parallelEventPulls: WorkspaceLimit.optional(),
-    parallelIncrementalEventPullsPerConnection: WorkspaceLimit.optional(),
-    parallelFullSyncEventPullsPerConnection: WorkspaceLimit.optional(),
-    parallelFlowRuns: WorkspaceLimit.optional(),
-    parallelFlowRunsPerConnection: WorkspaceLimit.optional(),
-    parallelApiRequests: WorkspaceLimit.optional(),
-    parallelSseRequests: WorkspaceLimit.optional(),
-    parallelBackgroundJobs: WorkspaceLimit.optional(),
-    parallelEventLogs: WorkspaceLimit.optional(),
-    parallelEventLogsPerConnection: WorkspaceLimit.optional(),
-    ParallelWriteDatabaseRequests: WorkspaceLimit.optional(),
-    fileUploadsMbPerHour: WorkspaceLimit.optional(),
-    apiRequestsPerSecond: WorkspaceLimit.optional(),
-    apiRequestsPerHour: WorkspaceLimit.optional(),
-    webhookRequestsPerSecond: WorkspaceLimit.optional(),
-    webhookRequestsPerHour: WorkspaceLimit.optional(),
-    workspaceElementCreationsPerSecond: WorkspaceLimit.optional(),
-    workspaceElementCreationsPerHour: WorkspaceLimit.optional(),
-    createDatabaseRequestsPerSecond: WorkspaceLimit.optional(),
-    totalNumberOfCustomers: WorkspaceLimit.optional(),
-    totalNumberOfConnections: WorkspaceLimit.optional(),
-    totalNumberOfWorkspaceElements: WorkspaceLimit.optional(),
-    parallelApiRequestsPerCustomer: WorkspaceLimit.optional(),
-    parallelBackgroundJobsPerCustomer: WorkspaceLimit.optional(),
-    apiRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
-    apiRequestsPerCustomerPerHour: WorkspaceLimit.optional(),
-    webhookRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
-    webhookRequestsPerCustomerPerHour: WorkspaceLimit.optional(),
-    externalEventsPerCustomerPerDay: WorkspaceLimit.optional(),
-    createDatabaseRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
-    updateDatabaseRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
-    parallelWriteDatabaseRequestsPerCustomer: WorkspaceLimit.optional(),
+const OrgWorkspaceSchema = z.z.object({
+    id: z.z.string(),
+    name: z.z.string(),
+    orgId: z.z.string(),
+    apiBaseUri: z.z.string().optional(),
+    key: z.z.string(),
+    secret: z.z.string(),
+    createdAt: z.z.coerce.date(),
+    updatedAt: z.z.coerce.date(),
+    engineAccessToken: z.z.string().optional(),
+    onboardingStep: z.z.nativeEnum(exports.WorkspaceOnboardingStep).optional(),
+    trialEndDate: z.z.string().optional(),
+    featureFlags: z.z.array(z.z.string()).optional(),
+    logoUri: z.z.string().optional(),
+});
+const OrgWorkspaceUser = z.z.object({
+    id: z.z.string(),
+    workspaceId: z.z.string(),
+    testCustomerId: z.z.string(),
+    userId: z.z.string(),
+    role: z.z.string(),
 });
-const EngineWorkspaceSettingsSchema = zod.z.object({
-    enableApiLogs: zod.z.boolean().optional(),
-    enableWebhookLogs: zod.z.boolean().optional(),
-    enableActionRunLogs: zod.z.boolean().optional(),
-    disableSecretKeyAuth: zod.z.boolean().optional(),
-});
-const AppPublicKey = zod.z.object({
-    name: zod.z.string(),
-    publicKey: zod.z.string(),
-});
-const AppSchema = zod.z.object({
-    id: zod.z.string(),
-    key: zod.z.string(),
-    logoUri: zod.z.string().optional(),
-    userFieldsSchema: zod.z.any().optional(),
-    apiBaseUri: zod.z.string().optional(),
-    webhookUri: zod.z.string().optional(),
-    publicKey: zod.z.string().optional(),
-    publicKeys: zod.z.array(AppPublicKey).optional(),
-    enabledWebhookEvents: zod.z.array(zod.z.string()).optional(),
-    auth: zod.z.any().optional(),
-    credentialsSchema: zod.z.any().optional(),
-    apiClient: zod.z.any().optional(),
-    apiRequestHeaders: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    apiRequestQuery: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    isOnPrem: zod.z.boolean().optional(),
-    connectorBaseUri: zod.z.string().optional(),
-    connectorRevision: zod.z.string().optional(),
-    featureFlags: zod.z.array(zod.z.string()).optional(),
-    limits: WorkspaceLimitsSchema.optional(),
-    settings: EngineWorkspaceSettingsSchema.optional(),
-    type: zod.z.nativeEnum(exports.WorkspaceType).optional(),
-    jwksUri: zod.z.string().nullable().optional(),
-    isTrial: zod.z.boolean().optional(),
-    isThrottled: zod.z.boolean().optional(),
-    isDisabled: zod.z.boolean().optional(),
-    isBackgroundJobsDisabled: zod.z.boolean().optional(),
-});
-
-const PlatformUserSchema = zod.z.object({
-    id: zod.z.string(),
-    email: zod.z.string(),
-    name: zod.z.string(),
-    trialRequested: zod.z.boolean(),
-    introVideoStatus: zod.z.string().optional(),
-    isEligible: zod.z.boolean().optional(),
-    emailVerified: zod.z.boolean().optional(),
-});
-const FullPlatformUser = zod.z.object({
-    id: zod.z.string(),
-    auth0Id: zod.z.string().optional(),
-    email: zod.z.string(),
-    name: zod.z.string(),
-    defaultAccountId: zod.z.string().optional(),
-    defaultWorkspaceId: zod.z.string().optional(),
-    isAdmin: zod.z.boolean().optional(),
-    trialRequested: zod.z.boolean(),
-    pat: zod.z.string().optional(),
-    introVideoStatus: zod.z.string().optional(),
-    isEligible: zod.z.boolean().optional(),
-    emailVerified: zod.z.boolean().optional(),
+
+exports.WorkspaceElementChangeType = void 0;
+(function (WorkspaceElementChangeType) {
+    WorkspaceElementChangeType["CREATE"] = "create";
+    WorkspaceElementChangeType["UPDATE"] = "update";
+    WorkspaceElementChangeType["DELETE"] = "delete";
+})(exports.WorkspaceElementChangeType || (exports.WorkspaceElementChangeType = {}));
+function compareWorkspaceExports(baseExport, targetExport) {
+    const changes = [];
+    const result = {
+        [exports.WorkspaceElementChangeType.CREATE]: new Set(),
+        [exports.WorkspaceElementChangeType.UPDATE]: new Set(),
+        [exports.WorkspaceElementChangeType.DELETE]: new Set(),
+    };
+    const integrationMap = buildIntegrationsMap([
+        ...(baseExport[exports.WorkspaceElementType.Integration] || []),
+        ...(targetExport[exports.WorkspaceElementType.Integration] || []),
+    ]);
+    const baseMap = new Map();
+    const targetMap = new Map();
+    const allSelectors = new Set();
+    const allElementTypes = new Set([...Object.keys(baseExport), ...Object.keys(targetExport)]);
+    for (const elementType of allElementTypes) {
+        const type = elementType;
+        const baseElements = baseExport[type] || [];
+        for (const element of baseElements) {
+            const intIdentifier = getIntegrationIdentifier(element, integrationMap);
+            const selector = getElementSelector(type, element.key, intIdentifier);
+            baseMap.set(selector, element);
+            allSelectors.add(selector);
+        }
+        const targetElements = targetExport[type] || [];
+        for (const element of targetElements) {
+            const intIdentifier = getIntegrationIdentifier(element, integrationMap);
+            const selector = getElementSelector(type, element.key, intIdentifier);
+            targetMap.set(selector, element);
+            allSelectors.add(selector);
+        }
+    }
+    for (const selector of allSelectors) {
+        const baseElement = baseMap.get(selector);
+        const targetElement = targetMap.get(selector);
+        const change = compareElementExports(baseElement, targetElement);
+        if (change) {
+            changes.push(change);
+        }
+    }
+    changes.forEach((change) => {
+        result[change.type].add(change.uuid);
+    });
+    return result;
+}
+function compareElementExports(baseElement, targetElement) {
+    if (baseElement && !targetElement) {
+        return {
+            type: exports.WorkspaceElementChangeType.DELETE,
+            uuid: baseElement.uuid,
+        };
+    }
+    if (!baseElement && targetElement) {
+        return {
+            type: exports.WorkspaceElementChangeType.CREATE,
+            uuid: targetElement.uuid,
+        };
+    }
+    if (baseElement && targetElement && !deepEqual(baseElement, targetElement)) {
+        return {
+            type: exports.WorkspaceElementChangeType.UPDATE,
+            uuid: targetElement.uuid,
+        };
+    }
+    return undefined;
+}
+function getIntegrationIdentifier(element, integrationMap) {
+    let integrationIdentifier;
+    if (element.integrationUuid) {
+        integrationIdentifier = integrationMap.get(element.integrationUuid);
+    }
+    if (element.integrationId) {
+        integrationIdentifier = integrationMap.get(element.integrationId);
+    }
+    return integrationIdentifier || element.integrationUuid || element.integrationId;
+}
+function getElementSelector(type, key, integrationIdentifier) {
+    if (integrationIdentifier) {
+        return `${type}:${key}:${integrationIdentifier}`;
+    }
+    return `${type}:${key}`;
+}
+function buildIntegrationsMap(integrations) {
+    const map = new Map();
+    for (const integration of integrations) {
+        if (integration.uuid && integration.key) {
+            map.set(integration.uuid, integration.key);
+            continue;
+        }
+        if (integration.id && integration.key) {
+            map.set(integration.id.toString(), integration.key);
+        }
+    }
+    return map;
+}
+
+const PlatformUserSchema = z.z.object({
+    id: z.z.string(),
+    email: z.z.string(),
+    name: z.z.string(),
+    trialRequested: z.z.boolean(),
+    introVideoStatus: z.z.string().optional(),
+    isEligible: z.z.boolean().optional(),
+    emailVerified: z.z.boolean().optional(),
+});
+const FullPlatformUser = z.z.object({
+    id: z.z.string(),
+    auth0Id: z.z.string().optional(),
+    email: z.z.string(),
+    name: z.z.string(),
+    defaultAccountId: z.z.string().optional(),
+    defaultWorkspaceId: z.z.string().optional(),
+    isAdmin: z.z.boolean().optional(),
+    trialRequested: z.z.boolean(),
+    pat: z.z.string().optional(),
+    introVideoStatus: z.z.string().optional(),
+    isEligible: z.z.boolean().optional(),
+    emailVerified: z.z.boolean().optional(),
 });
 
 exports.OrgLimitsType = void 0;
@@ -10848,54 +10912,58 @@ exports.OrgUserStatus = void 0;
     OrgUserStatus["Invited"] = "invited";
     OrgUserStatus["Active"] = "active";
 })(exports.OrgUserStatus || (exports.OrgUserStatus = {}));
-const OrgLimits = zod.z
+const OrgLimits = z.z
     .object({
-    numberOfWorkspaces: zod.z.number().optional(),
-    todayUsage: zod.z.number().optional(),
-    lastThirtyDayUsage: zod.z.number().optional(),
-    membraneAgentLastThirtyDaysUsage: zod.z.number().optional(),
-    membraneExpertCreditsCapPerMonth: zod.z.number().nullable().optional(),
+    numberOfWorkspaces: z.z.number().optional(),
+    todayUsage: z.z.number().optional(),
+    lastThirtyDayUsage: z.z.number().optional(),
+    membraneAgentLastThirtyDaysUsage: z.z.number().optional(),
+    membraneExpertCreditsCapPerMonth: z.z.number().nullable().optional(),
 })
     .optional();
-const MembraneAgentKey = zod.z
+const MembraneAgentKey = z.z
     .object({
-    key: zod.z.string().optional(),
-    expiresAt: zod.z.string().optional(),
+    key: z.z.string().optional(),
+    expiresAt: z.z.string().optional(),
 })
     .optional();
-const OrgSchema = zod.z.object({
-    id: zod.z.string(),
-    key: zod.z.string(),
-    name: zod.z.string(),
-    createdAt: zod.z.coerce.date(),
-    updatedAt: zod.z.coerce.date(),
-    trialEndDate: zod.z.string().optional(),
-    lastTrialExtensionDate: zod.z.string().optional(),
+const OrgSchema = z.z.object({
+    id: z.z.string(),
+    key: z.z.string(),
+    name: z.z.string(),
+    createdAt: z.z.coerce.date(),
+    updatedAt: z.z.coerce.date(),
+    trialEndDate: z.z.string().optional(),
+    lastTrialExtensionDate: z.z.string().optional(),
     limits: OrgLimits,
-    thirtyDayTotalCredits: zod.z.number().optional(),
-    lastThirtyDayUsagePercent: zod.z.number().optional(),
-    todayUsagePercent: zod.z.number().optional(),
-    domains: zod.z.array(zod.z.string()).optional(),
-    featureFlags: zod.z.array(zod.z.string()).optional(),
-    freeAiMonthlyCredits: zod.z.number().optional(),
-    paidAiCredits: zod.z.number().optional(),
-    stripeCustomerId: zod.z.string().optional(),
-});
-const AccountResponse = zod.z.object({
+    thirtyDayTotalCredits: z.z.number().optional(),
+    lastThirtyDayUsagePercent: z.z.number().optional(),
+    todayUsagePercent: z.z.number().optional(),
+    domains: z.z.array(z.z.string()).optional(),
+    featureFlags: z.z.array(z.z.string()).optional(),
+    freeAiMonthlyCredits: z.z.number().optional(),
+    paidAiCredits: z.z.number().optional(),
+    stripeCustomerId: z.z.string().optional(),
+    autoChargeEnabled: z.z.boolean().optional(),
+    autoChargeThreshold: z.z.number().optional(),
+    autoChargePurchaseAmount: z.z.number().optional(),
+    autoChargeMonthlyLimit: z.z.number().optional(),
+});
+const AccountResponse = z.z.object({
     user: FullPlatformUser.optional(),
     workspace: OrgWorkspaceSchema.optional(),
-    workspaces: zod.z.array(OrgWorkspaceSchema).optional(),
+    workspaces: z.z.array(OrgWorkspaceSchema).optional(),
     workspaceUser: OrgWorkspaceUser.extend({
-        testCustomerId: zod.z.string(),
+        testCustomerId: z.z.string(),
     }).optional(),
     engineTestUser: BaseCustomer.optional(),
     testCustomer: BaseCustomer.optional(),
     engineApp: AppSchema.optional(),
-    superAdminToken: zod.z.string().optional().nullable(),
-    orgs: zod.z.array(OrgSchema).optional(),
-    permissions: zod.z.array(zod.z.string()).optional(),
-    message: zod.z.string().optional(),
-    error: zod.z.string().optional(),
+    superAdminToken: z.z.string().optional().nullable(),
+    orgs: z.z.array(OrgSchema).optional(),
+    permissions: z.z.array(z.z.string()).optional(),
+    message: z.z.string().optional(),
+    error: z.z.string().optional(),
 });
 
 exports.WebhookTypeEnum = void 0;
@@ -10906,6 +10974,7 @@ exports.WebhookTypeEnum = void 0;
     WebhookTypeEnum["TASK_CREATED"] = "task-created";
     WebhookTypeEnum["TASK_UPDATED"] = "task-updated";
     WebhookTypeEnum["TASK_ACTIVITY_CREATED"] = "task-activity-created";
+    WebhookTypeEnum["CONNECTOR_VERSION_PUBLISHED"] = "connector-version-published";
 })(exports.WebhookTypeEnum || (exports.WebhookTypeEnum = {}));
 
 exports.AlertStatus = void 0;
@@ -12577,6 +12646,7 @@ class ExternalEventSubscriptionAccessor {
 exports.WorkspaceSyncEventType = void 0;
 (function (WorkspaceSyncEventType) {
     WorkspaceSyncEventType["ElementUpdate"] = "element-update";
+    WorkspaceSyncEventType["Connected"] = "connected";
 })(exports.WorkspaceSyncEventType || (exports.WorkspaceSyncEventType = {}));
 exports.ConnectorFileUpdateType = void 0;
 (function (ConnectorFileUpdateType) {
@@ -12594,44 +12664,44 @@ exports.ScenarioTemplateCategory = void 0;
     ScenarioTemplateCategory["UnifiedApi"] = "unified-api";
     ScenarioTemplateCategory["DataEnrichment"] = "data-enrichment";
 })(exports.ScenarioTemplateCategory || (exports.ScenarioTemplateCategory = {}));
-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
+const HandyScenarioTemplateElement = z.z.object({
+    type: z.z.string(),
+    integration: z.z.object({ key: z.z.string(), connectorId: z.z.string() }).optional(),
+    integrations: z.z.array(z.z.object({ key: z.z.string(), connectorId: z.z.string() })).optional(),
+    fields: z.z
         .object({
-        key: zod.z.string(),
-        name: zod.z.string(),
+        key: z.z.string(),
+        name: z.z.string(),
     })
-        .and(zod.z.record(zod.z.string(), 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(zod.z.string(), withIntegrationKeys(zod.z.any())).optional(),
-    actions: zod.z.record(zod.z.string(), withIntegrationKeys(zod.z.any())).optional(),
-    fieldMappings: zod.z.record(zod.z.string(), withIntegrationKeys(zod.z.any())).optional(),
-    dataSources: zod.z.record(zod.z.string(), withIntegrationKeys(zod.z.any())).optional(),
-    dataLinkTables: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    appEventTypes: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-    appDataSchemas: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-});
-const ScenarioTemplateElements = ElementsExportFields.and(zod.z.object({
-    integrations: zod.z.record(zod.z.string(), ElementsExportFields.and(zod.z.object({ connectorId: zod.z.string() }))).optional(),
+        .and(z.z.record(z.z.string(), z.z.any())),
+});
+const withIntegrationKeys = (schema) => schema.and(z.z.object({ integrationKeys: z.z.array(z.z.string()).optional() }));
+const ElementsExportFields = z.z.object({
+    flows: z.z.record(z.z.string(), withIntegrationKeys(z.z.any())).optional(),
+    actions: z.z.record(z.z.string(), withIntegrationKeys(z.z.any())).optional(),
+    fieldMappings: z.z.record(z.z.string(), withIntegrationKeys(z.z.any())).optional(),
+    dataSources: z.z.record(z.z.string(), withIntegrationKeys(z.z.any())).optional(),
+    dataLinkTables: z.z.record(z.z.string(), z.z.any()).optional(),
+    appEventTypes: z.z.record(z.z.string(), z.z.any()).optional(),
+    appDataSchemas: z.z.record(z.z.string(), z.z.any()).optional(),
+});
+const ScenarioTemplateElements = ElementsExportFields.and(z.z.object({
+    integrations: z.z.record(z.z.string(), ElementsExportFields.and(z.z.object({ connectorId: z.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.enum(exports.ScenarioTemplateCategory)).optional(),
+const ScenarioTemplate = z.z.object({
+    id: z.z.string(),
+    name: z.z.string(),
+    key: z.z.string(),
+    shortDescription: z.z.string().optional(),
+    description: z.z.string().optional(),
+    demoWorkspaceKey: z.z.string().optional(),
+    demoAppUri: z.z.string().optional(),
+    demoGithubRepo: z.z.string().optional(),
+    demoVideoYoutubeUri: z.z.string().optional(),
+    tags: z.z.array(z.z.enum(exports.ScenarioTemplateCategory)).optional(),
     elements: ScenarioTemplateElements.optional(),
-    connectors: zod.z.array(MinimalConnector).optional(),
-    handyElements: zod.z.array(HandyScenarioTemplateElement).optional(),
+    connectors: z.z.array(MinimalConnector).optional(),
+    handyElements: z.z.array(HandyScenarioTemplateElement).optional(),
 });
 
 exports.AgentSessionStatus = void 0;
@@ -12643,35 +12713,35 @@ exports.AgentSessionStatus = void 0;
     AgentSessionStatus["FAILED"] = "failed";
     AgentSessionStatus["CANCELLED"] = "cancelled";
 })(exports.AgentSessionStatus || (exports.AgentSessionStatus = {}));
-const AgentSession = zod.z.object({
-    id: zod.z.string(),
-    workspaceId: zod.z.string(),
-    workspaceElementType: zod.z.enum(exports.WorkspaceElementType),
-    workspaceElementId: zod.z.string(),
-    type: zod.z.string(),
-    status: zod.z.enum(exports.AgentSessionStatus),
-    workerId: zod.z.string().optional(),
-    workerUrl: zod.z.string().url().optional(),
-    prompt: zod.z.string(),
+const AgentSession = z.z.object({
+    id: z.z.string(),
+    workspaceId: z.z.string(),
+    workspaceElementType: z.z.enum(exports.WorkspaceElementType),
+    workspaceElementId: z.z.string(),
+    type: z.z.string(),
+    status: z.z.enum(exports.AgentSessionStatus),
+    workerId: z.z.string().optional(),
+    workerUrl: z.z.string().url().optional(),
+    prompt: z.z.string(),
     error: ErrorDataSchema.optional(),
-    createdBy: zod.z.string(),
-    lastActivityAt: zod.z.iso.datetime(),
-    createdAt: zod.z.iso.datetime(),
-    updatedAt: zod.z.iso.datetime(),
-    storedMessagesUri: zod.z.string().url().optional(),
-    sessionFilesZipUri: zod.z.string().url().optional(),
-    logs: zod.z.array(zod.z.any()).optional(),
-    usage: zod.z.number().optional(),
-});
-const CreateAgentSession = zod.z.object({
-    workspaceElementType: zod.z.enum(exports.WorkspaceElementType),
-    workspaceElementId: zod.z.string().min(1),
-    prompt: zod.z.string().min(1),
-    testCustomerId: zod.z.string().optional(),
-});
-const AgentSessionInputSchema = zod.z.object({
-    input: zod.z.string().min(1),
-    synthetic: zod.z.boolean().optional(),
+    createdBy: z.z.string(),
+    lastActivityAt: z.z.iso.datetime(),
+    createdAt: z.z.iso.datetime(),
+    updatedAt: z.z.iso.datetime(),
+    storedMessagesUri: z.z.string().url().optional(),
+    sessionFilesZipUri: z.z.string().url().optional(),
+    logs: z.z.array(z.z.any()).optional(),
+    usage: z.z.number().optional(),
+});
+const CreateAgentSession = z.z.object({
+    workspaceElementType: z.z.enum(exports.WorkspaceElementType).optional(),
+    workspaceElementId: z.z.string().min(1).optional(),
+    prompt: z.z.string().min(1),
+    testCustomerId: z.z.string().optional(),
+});
+const AgentSessionInputSchema = z.z.object({
+    input: z.z.string().min(1),
+    synthetic: z.z.boolean().optional(),
 });
 
 const API_VERSIONS = {
@@ -13004,6 +13074,8 @@ exports.AgentSessionInputSchema = AgentSessionInputSchema;
 exports.ApiRequestSpec = ApiRequestSpec;
 exports.AppDataSchemaAccessor = AppDataSchemaAccessor;
 exports.AppDataSchemaApiResponse = AppDataSchemaApiResponse;
+exports.AppDataSchemaEditableProperties = AppDataSchemaEditableProperties;
+exports.AppDataSchemaExportProperties = AppDataSchemaExportProperties;
 exports.AppDataSchemaInstanceAccessor = AppDataSchemaInstanceAccessor;
 exports.AppDataSchemaInstanceApiResponse = AppDataSchemaInstanceApiResponse;
 exports.AppDataSchemaInstancesAccessor = AppDataSchemaInstancesAccessor;
@@ -13014,8 +13086,9 @@ exports.AppEventSubscriptionApiResponse = AppEventSubscriptionApiResponse;
 exports.AppEventSubscriptionsAccessor = AppEventSubscriptionsAccessor;
 exports.AppEventTypeAccessor = AppEventTypeAccessor;
 exports.AppEventTypeApiResponse = AppEventTypeApiResponse;
+exports.AppEventTypeEditableProperties = AppEventTypeEditableProperties;
+exports.AppEventTypeExportProperties = AppEventTypeExportProperties;
 exports.AppEventTypesAccessor = AppEventTypesAccessor;
-exports.AppPublicKey = AppPublicKey;
 exports.AppSchema = AppSchema;
 exports.AppliedToIntegrations = AppliedToIntegrations;
 exports.BackwardCompatibleDataSourceEditableProperties = BackwardCompatibleDataSourceEditableProperties;
@@ -13097,6 +13170,7 @@ exports.CreateActionRequest = CreateActionRequest;
 exports.CreateAgentSession = CreateAgentSession;
 exports.CreateConnectionRequest = CreateConnectionRequest;
 exports.CreateCustomerRequest = CreateCustomerRequest;
+exports.CreateDataLinkTableRequest = CreateDataLinkTableRequest;
 exports.CreateDataSourceInstanceRequest = CreateDataSourceInstanceRequest;
 exports.CreateDataSourceRequest = CreateDataSourceRequest;
 exports.CreateFieldMappingRequest = CreateFieldMappingRequest;
@@ -13151,6 +13225,8 @@ exports.DataLink = DataLink;
 exports.DataLinkTableAccessor = DataLinkTableAccessor;
 exports.DataLinkTableApiResponse = DataLinkTableApiResponse;
 exports.DataLinkTableConfig = DataLinkTableConfig;
+exports.DataLinkTableEditableProperties = DataLinkTableEditableProperties;
+exports.DataLinkTableExportProperties = DataLinkTableExportProperties;
 exports.DataLinkTableInstanceAccessor = DataLinkTableInstanceAccessor;
 exports.DataLinkTableInstanceApiResponse = DataLinkTableInstanceApiResponse;
 exports.DataLinkTableInstancesAccessor = DataLinkTableInstancesAccessor;
@@ -13205,6 +13281,7 @@ exports.FindActionsQuery = FindActionsQuery;
 exports.FindConnectionsQuery = FindConnectionsQuery;
 exports.FindConnectionsResponse = FindConnectionsResponse;
 exports.FindCustomersQuery = FindCustomersQuery;
+exports.FindDataLinkTablesQuery = FindDataLinkTablesQuery;
 exports.FindDataSourceEventsQuery = FindDataSourceEventsQuery;
 exports.FindDataSourceInstanceSyncsQuery = FindDataSourceInstanceSyncsQuery;
 exports.FindDataSourceInstancesQuery = FindDataSourceInstancesQuery;
@@ -13255,6 +13332,7 @@ exports.InsufficientCreditsError = InsufficientCreditsError;
 exports.IntegrationAccessor = IntegrationAccessor;
 exports.IntegrationApiResponse = IntegrationApiResponse;
 exports.IntegrationAppClient = MembraneClient;
+exports.IntegrationAppError = IntegrationAppError;
 exports.IntegrationAuthOption = IntegrationAuthOption;
 exports.IntegrationAuthUi = IntegrationAuthUi;
 exports.IntegrationExportProperties = IntegrationExportProperties;
@@ -13325,6 +13403,7 @@ exports.UpdateActionInstanceRequest = UpdateActionInstanceRequest;
 exports.UpdateActionRequest = UpdateActionRequest;
 exports.UpdateConnectionRequest = UpdateConnectionRequest;
 exports.UpdateCustomerRequest = UpdateCustomerRequest;
+exports.UpdateDataLinkTableRequest = UpdateDataLinkTableRequest;
 exports.UpdateDataSourceInstanceRequest = UpdateDataSourceInstanceRequest;
 exports.UpdateDataSourceRequest = UpdateDataSourceRequest;
 exports.UpdateFieldMappingRequest = UpdateFieldMappingRequest;
@@ -13337,6 +13416,7 @@ exports.UsersAccessor = UsersAccessor;
 exports.WORKSPACE_SIZE_LIMITS = WORKSPACE_SIZE_LIMITS;
 exports.WorkspaceElementSpecs = WorkspaceElementSpecs;
 exports.WorkspaceLimitsSchema = WorkspaceLimitsSchema;
+exports.WorkspacePublicKey = WorkspacePublicKey;
 exports.__resolveValue = __resolveValue;
 exports.addRequiredFieldsToSchema = addRequiredFieldsToSchema;
 exports.addUdmFallbackFields = addUdmFallbackFields;
@@ -13375,6 +13455,7 @@ exports.getDataCollectionCreateFields = getDataCollectionCreateFields;
 exports.getDataCollectionUpdateFields = getDataCollectionUpdateFields;
 exports.getDataLocationMethodPath = getDataLocationMethodPath;
 exports.getDownstreamNodeKeys = getDownstreamNodeKeys;
+exports.getElementSelector = getElementSelector;
 exports.getErrorFromData = getErrorFromData;
 exports.getEventMethodFileKey = getEventMethodFileKey;
 exports.getFilterFieldValuesByLocator = getFilterFieldValuesByLocator;