@membranehq/sdk 0.28.3 → 0.29.0

package/dist/index.node.js

@@ -58,6 +58,7 @@ exports.BadRequestErrorKey = void 0;
     BadRequestErrorKey["ACCESS_DENIED"] = "access_denied";
     BadRequestErrorKey["ALREADY_EXISTS"] = "already_exists";
     BadRequestErrorKey["RATE_LIMIT_EXCEEDED"] = "rate_limit_exceeded";
+    BadRequestErrorKey["WORKSPACE_TIER_GATED"] = "workspace_tier_gated";
 })(exports.BadRequestErrorKey || (exports.BadRequestErrorKey = {}));
 exports.ConnectionErrorKey = void 0;
 (function (ConnectionErrorKey) {
@@ -195,6 +196,11 @@ class AccessDeniedError extends BadRequestError {
         this.data.key = exports.BadRequestErrorKey.ACCESS_DENIED;
     }
 }
+class RemoteConnectorCodeUnavailableError extends BadRequestError {
+    constructor(arg) {
+        super(arg !== null && arg !== void 0 ? arg : 'Operation execution requires connector code, which is not available for connectors served from the remote repository.');
+    }
+}
 class CustomCodeError extends MembraneError {
     constructor(arg) {
         super(arg);
@@ -2494,30 +2500,36 @@ class Eval extends DataBuilderFormulaBase {
         }
     }
 }
+function asLiteralOperandSchema(schema) {
+    if (!schema)
+        return schema;
+    const { readOnly: _readOnly, ...rest } = schema;
+    return rest;
+}
 const OPERATOR_SPECS = {
     is: {
         name: 'is',
         handler: (value, operand) => value == operand,
         applicableToSchema: (schema) => schemaIsScalar(schema),
-        getOperandSchema: (schema) => schema,
+        getOperandSchema: (schema) => asLiteralOperandSchema(schema),
     },
     isNot: {
         name: 'is not',
         handler: (value, operand) => value != operand,
         applicableToSchema: (schema) => schemaIsScalar(schema),
-        getOperandSchema: (schema) => schema,
+        getOperandSchema: (schema) => asLiteralOperandSchema(schema),
     },
     oneOf: {
         name: 'is one of',
         handler: (value, operand) => Array.isArray(operand) && operand.includes(value),
         applicableToSchema: (schema) => schemaIsScalar(schema) && schema.type !== 'boolean',
-        getOperandSchema: (schema) => ({ type: 'array', items: schema }),
+        getOperandSchema: (schema) => ({ type: 'array', items: asLiteralOperandSchema(schema) }),
     },
     noneOf: {
         name: 'is not one of',
         handler: (value, operand) => !Array.isArray(operand) || !operand.includes(value),
         applicableToSchema: (schema) => schemaIsScalar(schema) && schema.type !== 'boolean',
-        getOperandSchema: (schema) => ({ type: 'array', items: schema }),
+        getOperandSchema: (schema) => ({ type: 'array', items: asLiteralOperandSchema(schema) }),
     },
     contains: {
         name: 'contains',
@@ -3497,6 +3509,7 @@ exports.WorkspaceElementType = void 0;
     WorkspaceElementType["ExternalEventSubscription"] = "external-event-subscription";
     WorkspaceElementType["ExternalEventLogRecord"] = "external-event-log-record";
     WorkspaceElementType["ExternalEventPull"] = "external-event-pull";
+    WorkspaceElementType["ExternalEventType"] = "external-event-type";
     WorkspaceElementType["Screen"] = "screen";
     WorkspaceElementType["ActionRunLogRecord"] = "action-run-log-record";
     WorkspaceElementType["ExternalApiLogRecord"] = "external-api-log-record";
@@ -3633,7 +3646,8 @@ const BaseIntegrationLevelMembraneInterfaceEditableProperties = BaseMembraneInte
 const BaseIntegrationLevelMembraneInterfaceReadOnlyProperties = BaseMembraneInterfaceReadOnlyProperties.extend({
     isCustomized: z.z.boolean().optional(),
 });
-const BaseIntegrationLevelMembraneInterfaceExportProperties = BaseMembraneInterfaceEditableProperties.extend({
+const BaseExportProperties = BaseMembraneInterfaceEditableProperties.required({ uuid: true, key: true });
+const BaseIntegrationLevelMembraneInterfaceExportProperties = BaseExportProperties.extend({
     integrationUuid: z.z.string().optional(),
     parentUuid: z.z.string().optional(),
     externalAppUuid: z.z.string().optional(),
@@ -3926,6 +3940,124 @@ const ACTIONS = {
     },
 };
 
+exports.HttpRequestMethod = void 0;
+(function (HttpRequestMethod) {
+    HttpRequestMethod["GET"] = "GET";
+    HttpRequestMethod["POST"] = "POST";
+    HttpRequestMethod["PATCH"] = "PATCH";
+    HttpRequestMethod["PUT"] = "PUT";
+    HttpRequestMethod["DELETE"] = "DELETE";
+})(exports.HttpRequestMethod || (exports.HttpRequestMethod = {}));
+const HttpRequestSpec = 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',
+    properties: {
+        uri: { type: 'string' },
+        method: {
+            type: 'string',
+            enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+        },
+        body: {},
+        query: {
+            type: 'object',
+            section: true,
+            additionalProperties: true,
+        },
+        headers: {
+            type: 'object',
+            section: true,
+            additionalProperties: true,
+        },
+    },
+};
+
+const ActionApiPayload = z.z.object({
+    method: z.z.enum(exports.HttpRequestMethod),
+    path: z.z.string().optional(),
+    url: z.z.string().optional(),
+    body: z.z.any().optional(),
+    headers: z.z.record(z.z.string(), z.z.string()).optional(),
+    query: z.z.record(z.z.string(), z.z.union([z.z.string(), z.z.number(), z.z.boolean()])).optional(),
+});
+const ActionSnapshot = z.z.object({
+    id: z.z.string().optional(),
+    integrationKey: z.z.string().optional(),
+    key: z.z.string().optional(),
+    connectionKey: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+    type: z.z.string(),
+    api: ActionApiPayload.optional(),
+    code: z.z.string().optional(),
+    input: z.z.any().optional(),
+    meta: z.z.record(z.z.string(), z.z.any()).optional(),
+});
+function configToNamedPayload(type, config) {
+    var _a, _b;
+    if (config == null)
+        return {};
+    switch (type) {
+        case exports.ActionType.ApiRequestToExternalApp:
+        case exports.ActionType.ApiRequestToYourApp:
+        case exports.ActionType.ApiRequest: {
+            const req = config.request;
+            if (!req)
+                return {};
+            return {
+                api: {
+                    method: req.method,
+                    path: req.path,
+                    body: (_a = req.data) !== null && _a !== void 0 ? _a : req.body,
+                    headers: req.headers,
+                    query: req.query,
+                },
+            };
+        }
+        case exports.ActionType.HttpRequest: {
+            const req = config.request;
+            if (!req)
+                return {};
+            return {
+                api: {
+                    method: req.method,
+                    url: req.uri,
+                    body: (_b = req.body) !== null && _b !== void 0 ? _b : req.data,
+                    headers: req.headers,
+                    query: req.query,
+                },
+            };
+        }
+        case exports.ActionType.RunJavascript: {
+            const code = config.code;
+            if (typeof code !== 'string')
+                return {};
+            return { code };
+        }
+        default:
+            return {};
+    }
+}
+function buildActionSnapshot(args) {
+    const { api, code } = configToNamedPayload(args.type, args.config);
+    return {
+        ...(args.id != null && { id: args.id }),
+        ...(args.integrationKey != null && { integrationKey: args.integrationKey }),
+        ...(args.key != null && { key: args.key }),
+        ...(args.connectionId != null && { connectionId: args.connectionId }),
+        ...(args.connectionKey != null && { connectionKey: args.connectionKey }),
+        type: args.type,
+        ...(api != null && { api }),
+        ...(code != null && { code }),
+        ...(args.input != null && { input: args.input }),
+        ...(args.meta != null && { meta: args.meta }),
+    };
+}
+
 exports.ActionDependencyType = void 0;
 (function (ActionDependencyType) {
     ActionDependencyType["FieldMapping"] = "FieldMapping";
@@ -4003,6 +4135,8 @@ const CreateConnectionRequestPayload = z.z.object({
     connectorId: z.z.string().optional(),
     connectorKey: z.z.string().optional(),
     connectorVersion: z.z.string().optional(),
+    externalAppId: z.z.string().optional(),
+    externalAppKey: z.z.string().optional(),
     connectionId: z.z.string().optional(),
     connectionKey: z.z.string().min(1).max(100).optional(),
     name: z.z.string().optional(),
@@ -4020,6 +4154,8 @@ const ConnectionRequest = z.z.object({
     connectorId: z.z.string().optional(),
     connectorKey: z.z.string().optional(),
     connectorVersion: z.z.string().optional(),
+    externalAppId: z.z.string().optional(),
+    externalAppKey: z.z.string().optional(),
     connectionId: z.z.string().optional(),
     connectionKey: z.z.string().optional(),
     name: z.z.string().optional(),
@@ -4057,6 +4193,7 @@ const ConnectionClientAction = z.z.object({
     description: z.z.string(),
     uiUrl: z.z.string().optional(),
     agentInstructions: z.z.string().optional(),
+    handoffAgentInstructions: z.z.string().optional(),
 });
 const BaseConnection = BaseWorkspaceElement.extend({
     ...TenantLayerElement.shape,
@@ -9209,21 +9346,25 @@ exports.ConnectorStatus = void 0;
 const ConnectorAuthWithFunctions = z.z.object({
     type: z.z
         .enum(['integration-app-token', 'membrane-token', 'oauth2', 'oauth1', 'client-credentials', 'proxy'])
-        .optional(),
-    credentialsSchema: DataSchema.optional(),
-    customCredentialsSchema: DataSchema.optional(),
-    inputSchema: DataSchema.optional(),
-    parametersSchema: DataSchema.optional(),
-    getCredentialsFromConnectionParameters: GenericFunctionDefinition.optional(),
-    refreshCredentials: GenericFunctionDefinition.optional(),
-    makeApiClient: GenericFunctionDefinition.optional(),
-    getOAuthConfig: GenericFunctionDefinition.optional(),
-    getTokenData: GenericFunctionDefinition.optional(),
-    getCredentialsFromAccessTokenResponse: GenericFunctionDefinition.optional(),
-    getCredentialsFromRefreshTokenResponse: GenericFunctionDefinition.optional(),
-    test: GenericFunctionDefinition.optional(),
-    disconnect: GenericFunctionDefinition.optional(),
-    proxyKey: z.z.string().optional(),
+        .optional()
+        .describe('Authentication protocol used by the connector.'),
+    credentialsSchema: DataSchema.optional().describe('JSON Schema describing the credentials produced by the auth flow (e.g. `access_token`, `refresh_token`). Usually inferred from the auth type; override only when the connector stores custom credential fields.'),
+    customCredentialsSchema: DataSchema.optional().describe('Additional JSON Schema for workspace-level overrides of credentials (e.g. BYO-OAuth clientId/clientSecret).'),
+    inputSchema: DataSchema.optional().describe('JSON Schema for end-user input collected during connection (e.g. an API key or subdomain the user types in).'),
+    parametersSchema: DataSchema.optional().describe('JSON Schema for connector-level parameters configured per integration (e.g. region, account ID).'),
+    getCredentialsFromConnectionParameters: GenericFunctionDefinition.optional().describe('Function that derives auth credentials from connection parameters. Use for static-key auth (api-key, basic-auth) where the user-provided input IS the credential.'),
+    refreshCredentials: GenericFunctionDefinition.optional().describe('Function that refreshes expired credentials. Implement for non-standard OAuth refresh flows or when additional credentials need to be refreshed alongside the OAuth token.'),
+    makeApiClient: GenericFunctionDefinition.optional().describe('Function that configures the HTTP client used by operations, actions and data sources. Typically a `mapping` type with `baseUri` and auth header wiring.'),
+    getOAuthConfig: GenericFunctionDefinition.optional().describe('OAuth2: function returning `{ authorizeUri, tokenUri, scopes, noRefreshToken? }` — the authorize/token endpoint URLs and requested scopes.'),
+    getTokenData: GenericFunctionDefinition.optional().describe('OAuth2: function invoked with the raw token response to extract token metadata. Rarely needed.'),
+    getCredentialsFromAccessTokenResponse: GenericFunctionDefinition.optional().describe('OAuth2: function that transforms the token endpoint response into the final credentials object. Required for multi-tenant APIs (Microsoft) or APIs that require post-OAuth bootstrap calls.'),
+    getCredentialsFromRefreshTokenResponse: GenericFunctionDefinition.optional().describe('OAuth2: function that transforms the refresh token endpoint response into the refreshed credentials. Required when refresh responses differ from initial-token responses.'),
+    test: GenericFunctionDefinition.optional().describe('Function that verifies the connection by making a lightweight authenticated API call (typically a `rest-api-mapping` against a `/me`-style endpoint).'),
+    disconnect: GenericFunctionDefinition.optional().describe('Function that revokes credentials at the provider when the connection is removed. Implement only if the provider exposes a revoke endpoint.'),
+    proxyKey: z.z
+        .string()
+        .optional()
+        .describe('For `type: "proxy"` — identifies which proxy configuration the workspace should use.'),
     ui: z.z
         .object({
         schema: DataSchema.optional(),
@@ -9255,13 +9396,16 @@ const GeneratedConnectorOption = z.z.object({
 const ConnectorOptions = z.z.record(z.z.string(), ConnectorOption);
 const WritableConnectorVersionData = ConnectorAuthWithFunctions.extend({
     parametersSchema: DataSchema.optional(),
-    options: z.z.record(z.z.string(), WriteableConnectorOption).optional(),
+    options: z.z
+        .record(z.z.string(), WriteableConnectorOption)
+        .optional()
+        .describe('Map of auth option key to auth configuration, for connectors that support multiple auth methods. Mutually exclusive with the top-level auth fields: use either the top-level fields (single-auth) OR `options` (multi-auth), not both.'),
 }).omit({
     credentialsSchema: true,
 });
 const ConnectorVersionData = z.z
     .object({
-    baseUri: z.z.string(),
+    baseUri: z.z.string().optional(),
     revision: z.z.string().optional(),
     dataCollectionsCount: z.z.number().optional(),
     operationsCount: z.z.number().optional(),
@@ -9296,10 +9440,10 @@ const WriteableConnectorFields = z.z
 })
     .extend(WritableConnectorVersionData.shape);
 const ConnectorExportProperties = WriteableConnectorFields.extend({
-    uuid: z.z.string().optional(),
-}).omit({
-    externalAppId: true,
-});
+    uuid: z.z.string(),
+})
+    .omit({ externalAppId: true })
+    .required({ key: true });
 const UpdateConnectorRequest = WriteableConnectorFields;
 const CreateConnectorRequest = WriteableConnectorFields.extend({
     name: z.z.string(),
@@ -9584,8 +9728,8 @@ var ApiTrigger = new FlowNodeSpec({
 });
 
 var AppEventTrigger = new FlowNodeSpec({
-    name: 'App Event Trigger',
-    description: 'Trigger flow when a matching App Event is received',
+    name: 'Internal Event Trigger',
+    description: 'Trigger flow when a matching Internal Event is received',
     isTrigger: true,
 });
 
@@ -9957,26 +10101,32 @@ const BaseIntegration = BaseMembraneInterface.extend({
 });
 const IntegrationEditableProperties = BaseMembraneInterfaceEditableProperties.extend({
     logoUri: z.z.string().optional(),
-    externalAppId: z.z.string().optional(),
+    externalAppId: z.z
+        .string()
+        .optional()
+        .describe("External app id; alternative to connectorId — resolves to the app's default connector."),
     externalAppUuid: z.z.string().optional(),
     appUuid: z.z.string().optional().describe('[INTERNAL] Deprecated: resolved to externalAppId'),
     oAuthCallbackUri: z.z.url().or(z.z.literal('')).optional(),
     logoBase64: z.z.string().optional(),
     connectorVersion: z.z.string().optional(),
-    connectorId: z.z.string().optional(),
+    connectorId: z.z.string().optional().describe('ID of the connector this integration uses.'),
     connectorUuid: z.z.string().optional(),
     connectorKey: z.z
         .string()
         .optional()
         .describe('Key of the connector; alternative to connectorId. Resolved to connectorId by the API.'),
-    parameters: z.z.record(z.z.string(), z.z.any()).optional(),
+    parameters: z.z
+        .record(z.z.string(), z.z.any())
+        .optional()
+        .describe('Connector-specific parameters (e.g. OAuth { clientId, clientSecret, scopes }).'),
     optionsConfig: IntegrationOptions.optional(),
 });
 const IntegrationExportProperties = IntegrationEditableProperties.omit({
     connectorId: true,
     externalAppId: true,
     parameters: true,
-});
+}).required({ uuid: true, key: true });
 const AppliedToIntegrations = (elementSchema) => z.z.array(z.z.object({
     element: elementSchema,
     integration: BaseIntegration,
@@ -10073,7 +10223,7 @@ const DataLinkTableSpecificProperties = z.z.object({
     dataLinkTableId: z.z.string().optional(),
 });
 const DataLinkTableEditableProperties = BaseMembraneInterfaceEditableProperties.extend(DataLinkTableSpecificProperties.shape);
-const DataLinkTableExportProperties = BaseMembraneInterfaceEditableProperties.extend(DataLinkTableSpecificProperties.shape).omit({
+const DataLinkTableExportProperties = BaseExportProperties.extend(DataLinkTableSpecificProperties.shape).omit({
     connectionId: true,
     dataLinkTableId: true,
 });
@@ -10096,43 +10246,6 @@ const DataLinkTableConfig = z.z.object({
     key: z.z.string(),
 });
 
-exports.HttpRequestMethod = void 0;
-(function (HttpRequestMethod) {
-    HttpRequestMethod["GET"] = "GET";
-    HttpRequestMethod["POST"] = "POST";
-    HttpRequestMethod["PATCH"] = "PATCH";
-    HttpRequestMethod["PUT"] = "PUT";
-    HttpRequestMethod["DELETE"] = "DELETE";
-})(exports.HttpRequestMethod || (exports.HttpRequestMethod = {}));
-const HttpRequestSpec = 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',
-    properties: {
-        uri: { type: 'string' },
-        method: {
-            type: 'string',
-            enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
-        },
-        body: {},
-        query: {
-            type: 'object',
-            section: true,
-            additionalProperties: true,
-        },
-        headers: {
-            type: 'object',
-            section: true,
-            additionalProperties: true,
-        },
-    },
-};
-
 const BaseAppEventType = BaseMembraneInterface.extend({
     revision: z.z.string(),
     archivedAt: z.z.string().optional(),
@@ -10151,7 +10264,7 @@ const AppEventTypeEditableProperties = BaseMembraneInterfaceEditableProperties.e
     userIdFormula: z.z.any().optional(),
     subscribeRequest: HttpRequestSpec.optional(),
 });
-const AppEventTypeExportProperties = BaseMembraneInterfaceEditableProperties.extend({});
+const AppEventTypeExportProperties = BaseExportProperties.extend({});
 
 const BaseAppEventSubscription = BaseMembraneInterface.extend({
     ...TenantLayerElement.shape,
@@ -10173,7 +10286,7 @@ const AppDataSchemaSpecificProperties = z.z.object({
     code: z.z.string().optional(),
 });
 const AppDataSchemaEditableProperties = BaseMembraneInterfaceEditableProperties.extend(AppDataSchemaSpecificProperties.shape);
-const AppDataSchemaExportProperties = AppDataSchemaEditableProperties.omit({
+const AppDataSchemaExportProperties = BaseExportProperties.extend(AppDataSchemaSpecificProperties.shape).omit({
     appDataSchemaId: true,
 });
 const AppDataSchemaReadOnlyProperties = BaseMembraneInterfaceReadOnlyProperties.extend({
@@ -10210,6 +10323,7 @@ const BaseExternalEventSubscription = TenantLayerElement.extend({
     name: z.z.string().optional(),
     connectionId: z.z.string(),
     integrationId: z.z.string(),
+    externalEventTypeId: z.z.string().optional(),
     config: ExternalEventSubscriptionConfig.optional(),
     status: z.z.enum(exports.ExternalEventSubscriptionStatus).optional(),
     error: ErrorDataSchema.optional(),
@@ -10226,6 +10340,7 @@ const BaseExternalEventSubscription = TenantLayerElement.extend({
     nextRefreshTimestamp: z.z.number().optional(),
     globalWebhookKey: z.z.string().optional(),
     globalWebhookEventSelector: z.z.string().optional(),
+    incomingWebhookUri: z.z.string().optional(),
     webhookUri: z.z.string().optional(),
 });
 
@@ -10240,6 +10355,7 @@ const BaseExternalEventLogRecord = ActivityLogRecord.extend({
     externalEventSubscriptionId: z.z.string(),
     integrationId: z.z.string(),
     connectionId: z.z.string(),
+    externalEventTypeId: z.z.string().optional(),
     payload: z.z.any().optional(),
     launchedFlowRunIds: z.z.array(z.z.string()).optional(),
     status: z.z.enum(exports.ExternalEventLogStatus),
@@ -10266,6 +10382,31 @@ const BaseExternalEventPull = ActivityLogRecord.extend({
     error: ErrorDataSchema.optional(),
 });
 
+exports.ExternalEventTypeImplementationType = void 0;
+(function (ExternalEventTypeImplementationType) {
+    ExternalEventTypeImplementationType["Webhook"] = "webhook";
+})(exports.ExternalEventTypeImplementationType || (exports.ExternalEventTypeImplementationType = {}));
+const EXTERNAL_EVENT_TYPE_FUNCTION_KEYS = ['subscribe', 'unsubscribe', 'handle', 'refresh'];
+const ExternalEventTypeCommonFields = {
+    schema: DataSchema.optional(),
+    parametersSchema: DataSchema.optional(),
+    example: z.z.any().optional(),
+    type: z.z.nativeEnum(exports.ExternalEventTypeImplementationType).optional(),
+    subscribe: GenericFunctionDefinition.optional(),
+    unsubscribe: GenericFunctionDefinition.optional(),
+    handle: GenericFunctionDefinition.optional(),
+    refresh: GenericFunctionDefinition.optional(),
+};
+const ExternalEventTypeEditableProperties = BaseIntegrationLevelMembraneInterfaceEditableProperties.extend({
+    ...ExternalEventTypeCommonFields,
+});
+const ExternalEventTypeExportProperties = BaseIntegrationLevelMembraneInterfaceExportProperties.extend({
+    ...ExternalEventTypeCommonFields,
+});
+const BaseExternalEventType = BaseIntegrationLevelMembraneInterface.extend({
+    ...ExternalEventTypeCommonFields,
+});
+
 exports.ActionRunLogStatus = void 0;
 (function (ActionRunLogStatus) {
     ActionRunLogStatus["SUCCESS"] = "success";
@@ -10279,8 +10420,10 @@ const BaseActionRunLogRecord = ActivityLogRecord.extend({
     actionId: z.z.string().optional().describe('[INTERNAL] Deprecated: Use integrationActionId instead'),
     actionInstanceId: z.z.string().optional().describe('[INTERNAL] Deprecated: Use connectionActionId instead'),
     integrationId: z.z.string(),
-    connectionId: z.z.string(),
-    input: z.z.any().optional(),
+    connectionId: z.z
+        .string()
+        .describe('[DEPRECATED] Deprecated: Read from action.connectionId or action.connectionKey instead'),
+    input: z.z.any().optional().describe('[DEPRECATED] Deprecated: Read from action.input instead'),
     output: z.z.any().optional(),
     status: z.z.enum(exports.ActionRunLogStatus),
     createdAt: z.z.string(),
@@ -10288,6 +10431,7 @@ const BaseActionRunLogRecord = ActivityLogRecord.extend({
     error: ErrorDataSchema.optional(),
     duration: z.z.number().optional(),
     meta: z.z.record(z.z.string(), z.z.any()).optional(),
+    action: ActionSnapshot.optional().describe('Complete /act-body snapshot of what ran — sufficient to replay the run by POSTing back to /act.'),
 });
 
 const ConnectedProductType = z.z.enum(['ai-agent', 'app']);
@@ -10433,7 +10577,6 @@ const ListActionInstancesForConnectionQuery = FindActionsQuery;
 const FindActionInstancesQuery = FindActionsQuery;
 
 const ActionRunLogRecordApiResponse = BaseActionRunLogRecord.extend({
-    action: BaseAction.optional(),
     actionInstance: BaseAction.optional(),
     integration: BaseIntegration.optional(),
     connection: BaseConnection.optional(),
@@ -10660,6 +10803,18 @@ const ConnectionMessagePayload = z.z.discriminatedUnion('type', [
         connectionId: z.z.string().optional(),
     }),
 ]);
+const ConnectionEntityMessagePayload = z.z.discriminatedUnion('type', [
+    z.z.object({
+        type: z.z.literal('connected'),
+        connectionId: z.z.string(),
+        timestamp: z.z.string(),
+        message: z.z.string().optional(),
+    }),
+    z.z.object({
+        type: z.z.literal('connectionPatched'),
+        connectionId: z.z.string(),
+    }),
+]);
 const GenerateOptionsRequest = z.z.object({
     integrationId: z.z.string().optional(),
     integrationKey: z.z.string().optional(),
@@ -10676,6 +10831,8 @@ const ConnectPayload = z.z.object({
     connectorId: z.z.string().optional(),
     connectorKey: z.z.string().optional(),
     connectorVersion: z.z.string().optional(),
+    externalAppId: z.z.string().optional(),
+    externalAppKey: z.z.string().optional(),
     connectionId: z.z.string().optional(),
     connectionKey: z.z.string().min(1).max(100).optional(),
     name: z.z.string().optional(),
@@ -10696,6 +10853,15 @@ const ConnectUIOptions = ConnectPayload.omit({ input: true, redirectUri: true })
 const ListPublicConnectorsQuery = PaginationQuery.merge(IncludeArchivedQuery).extend({
     search: z.z.string().optional(),
 });
+const ListConnectorsQuery = z.z.object({
+    limit: z.z.coerce.number().optional(),
+    cursor: z.z.string().optional(),
+    workspaceId: z.z.string().optional().describe('[INTERNAL] Legacy field for backward compatibility'),
+    search: z.z.string().optional(),
+    appUuid: z.z.string().optional(),
+    externalAppId: z.z.string().optional(),
+    includeArchived: zodBooleanCoercion().optional(),
+});
 
 const DataSourceApiResponse = BaseDataSource.extend({
     integration: BaseIntegration.optional(),
@@ -10784,6 +10950,27 @@ const ListExternalAppsQuery = PaginationQuery.merge(IncludeArchivedQuery).extend
         isFlag: true,
     }),
 });
+const CreateExternalAppRequest = z.z.object({
+    key: z.z.string().min(1).describe('Machine key (e.g., "attio"). Unique per workspace.'),
+    name: z.z.string().min(1).describe('Human-readable app name (e.g., "Attio").'),
+    appUri: z.z.url().optional().describe('App\'s main URL (e.g., "https://attio.com").'),
+    logoUri: z.z.url().optional(),
+    categories: z.z.array(z.z.string()).optional().describe('[INTERNAL] Categorization tags used by the Universe catalog.'),
+    defaultConnectorId: z.z
+        .string()
+        .optional()
+        .describe('[INTERNAL] Connector ID surfaced as the default for this app in the Universe catalog.'),
+    basePackageId: z.z.string().optional().describe('[INTERNAL] Base package ID this app is derived from.'),
+    hasFreeTestAccount: z.z.boolean().nullable().optional().describe('[INTERNAL] Whether the app has a free test account.'),
+    freeTestAccountGuide: z.z.string().optional().describe('[INTERNAL] Guide for obtaining a free test account.'),
+    freeTestAccountGuideVerifiedAt: z.z.iso
+        .datetime()
+        .nullable()
+        .optional()
+        .describe('[INTERNAL] When the free test account guide was last verified.'),
+    tenantId: z.z.string().optional(),
+});
+const UpdateExternalAppRequest = CreateExternalAppRequest.partial();
 
 const ExternalEvent = BaseExternalEvent.extend({
     appliedToIntegrations: AppliedToIntegrations(BaseExternalEvent).optional(),
@@ -10917,7 +11104,7 @@ const FindFlowRunsResponse = z.z.object({
     cursor: z.z.string().optional(),
 });
 
-const CreateIntegrationRequest = IntegrationEditableProperties;
+const CreateIntegrationRequest = IntegrationEditableProperties.merge(IntentProperties);
 const UpdateIntegrationRequest = IntegrationEditableProperties.partial();
 const FindIntegrationsQuery = z.z
     .object({
@@ -10934,6 +11121,10 @@ const FindIntegrationsQuery = z.z
         .number()
         .optional()
         .describe('Override auto-generate integrations from web search: 1 to enable, 0 to disable'),
+    all: z.z.coerce
+        .number()
+        .optional()
+        .describe('Enable all auto-generation sources (connectors, external apps, web search) regardless of workspace settings or per-source flags'),
 })
     .merge(PaginationQuery)
     .merge(SearchQuery)
@@ -10957,12 +11148,12 @@ const IntegrationApiResponse = BaseIntegration.extend({
         .array(IntegrationAuthOption)
         .optional()
         .describe('[INTERNAL] Deprecated: Use POST /connectors/:id/generate-options instead'),
-});
-const IntegrationListItem = IntegrationApiResponse.extend({
     id: z.z.string().optional(),
     logoUri: z.z.string().optional(),
     appUri: z.z.string().optional(),
+    isConnected: z.z.boolean().optional(),
 });
+const IntegrationListItem = IntegrationApiResponse;
 
 const PackageElementApi = z.z.object({
     id: z.z.string(),
@@ -11010,7 +11201,6 @@ const CheckpointApiResponse = z.z.object({
     checkpointNumber: z.z.number(),
     snapshot: z.z.record(z.z.string(), z.z.unknown()),
     createdAt: z.z.string(),
-    createdBy: z.z.string().optional(),
     metadata: z.z.record(z.z.string(), z.z.unknown()).optional(),
 });
 const CheckpointDiffOperationSchema = z.z.object({
@@ -11342,6 +11532,13 @@ const ListExternalEventLogRecordsQuery = PaginationQuery.extend({
         filterTitle: 'Event Subscription',
         referenceElementType: exports.WorkspaceElementType.ExternalEventSubscription,
     }),
+    externalEventTypeId: z.z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'External Event Type',
+        referenceElementType: exports.WorkspaceElementType.ExternalEventType,
+    }),
     status: z.z
         .enum(exports.ExternalEventLogStatus)
         .optional()
@@ -11493,6 +11690,13 @@ const ListExternalEventSubscriptionsQuery = PaginationQuery.merge(IncludeArchive
     externalAppId: z.z.string().optional().meta({
         hidden: true,
     }),
+    externalEventTypeId: z.z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'External Event Type',
+        referenceElementType: exports.WorkspaceElementType.ExternalEventType,
+    }),
     status: z.z
         .enum(exports.ExternalEventSubscriptionStatus)
         .optional()
@@ -11500,11 +11704,56 @@ const ListExternalEventSubscriptionsQuery = PaginationQuery.merge(IncludeArchive
         filterTitle: 'Status',
     }),
 });
+const CreateExternalEventSubscriptionRequest = z.z.object({
+    connectionId: z.z.string(),
+    externalEventTypeId: z.z.string(),
+});
 const ExternalEventSubscriptionApiResponse = BaseExternalEventSubscription.extend({
     user: BaseCustomer.optional(),
     connection: BaseConnection.optional(),
     integration: BaseIntegration.optional(),
 });
+const PatchExternalEventSubscriptionRequest = z.z.object({
+    webhookUri: z.z.url().or(z.z.literal('')).optional(),
+});
+
+const CreateExternalEventTypeRequest = ExternalEventTypeEditableProperties.extend({
+    name: z.z.string(),
+});
+const UpdateExternalEventTypeRequest = ExternalEventTypeEditableProperties;
+const FindExternalEventTypesQuery = FindIntegrationLevelMembraneInterfaceQuery.extend({
+    isUniversal: zodBooleanCoercion()
+        .optional()
+        .meta({
+        filterTitle: 'Is Universal',
+        isFlag: true,
+    }),
+    externalAppId: z.z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'External App',
+        referenceElementType: exports.WorkspaceElementType.App,
+    }),
+    tenantId: z.z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'Tenant',
+        referenceElementType: exports.WorkspaceElementType.Customer,
+    }),
+    parentId: z.z
+        .string()
+        .optional()
+        .meta({ hidden: true }),
+    universalParentId: z.z
+        .string()
+        .optional()
+        .meta({ hidden: true }),
+});
+const ExternalEventTypeApiResponse = BaseExternalEventType.extend({
+    appliedToIntegrations: AppliedToIntegrations(BaseExternalEventType).optional(),
+});
 
 const ListAppEventLogRecordsQuery = CommonListElementsQuery.extend({
     tenantId: z.z
@@ -11641,6 +11890,13 @@ const ListIncomingWebhooksQuery = PaginationQuery.extend({
         filterTitle: 'Connection',
         referenceElementType: exports.WorkspaceElementType.Connection,
     }),
+    subscriptionId: z.z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'Subscription',
+        referenceElementType: exports.WorkspaceElementType.ExternalEventSubscription,
+    }),
     status: z.z
         .enum(exports.IncomingWebhooksState)
         .optional()
@@ -11971,6 +12227,7 @@ const AI_GATEWAY_SUPPORTED_MODELS = [
     { id: 'anthropic/claude-opus-4.6', name: 'Claude Opus 4.6' },
     { id: 'anthropic/claude-sonnet-4.5', name: 'Claude Sonnet 4.5' },
     { id: 'anthropic/claude-opus-4.5', name: 'Claude Opus 4.5' },
+    { id: 'anthropic/claude-haiku-4.5', name: 'Claude Haiku 4.5' },
     { id: 'openai/gpt-5.2', name: 'GPT-5.2' },
     { id: 'openai/gpt-5-nano', name: 'GPT-5 Nano' },
     { id: 'google/gemini-3-pro-preview', name: 'Gemini 3 Pro' },
@@ -12192,6 +12449,8 @@ const WorkspaceElementSpecs = {
         editablePropertiesSchema: IntegrationEditableProperties,
         exportPropertiesSchema: IntegrationExportProperties,
         hasKey: true,
+        isAgentic: true,
+        agentName: exports.AgentName.CONNECTION_BUILDING,
         relatedIntegrationLayerElements: [
             exports.WorkspaceElementType.Connection,
             exports.WorkspaceElementType.Package,
@@ -12446,8 +12705,8 @@ const WorkspaceElementSpecs = {
     [exports.WorkspaceElementType.AppEventType]: {
         type: exports.WorkspaceElementType.AppEventType,
         apiPath: 'app-event-types',
-        name: 'App Event Type',
-        namePlural: 'App Event Types',
+        name: 'Internal Event Type',
+        namePlural: 'Internal Event Types',
         isMembraneInterface: true,
         exportPropertiesSchema: AppEventTypeExportProperties,
         editablePropertiesSchema: AppEventTypeEditableProperties,
@@ -12459,8 +12718,8 @@ const WorkspaceElementSpecs = {
         type: exports.WorkspaceElementType.AppEventSubscription,
         apiPath: 'app-event-subscriptions',
         collectionName: 'app-event-subscriptions',
-        name: 'App Event Subscription',
-        namePlural: 'App Event Subscriptions',
+        name: 'Internal Event Subscription',
+        namePlural: 'Internal Event Subscriptions',
         isMembraneInterface: true,
         isProOnly: true,
         statsKey: 'appEventSubscriptions',
@@ -12468,8 +12727,8 @@ const WorkspaceElementSpecs = {
     [exports.WorkspaceElementType.AppEventLogRecord]: {
         type: exports.WorkspaceElementType.AppEventLogRecord,
         apiPath: 'app-events',
-        name: 'App Event Log Record',
-        namePlural: 'App Event Log Records',
+        name: 'Internal Event Log Record',
+        namePlural: 'Internal Event Log Records',
         isProOnly: true,
         statsKey: 'appEvents',
     },
@@ -12523,6 +12782,24 @@ const WorkspaceElementSpecs = {
         isProOnly: true,
         statsKey: 'externalEventPulls',
     },
+    [exports.WorkspaceElementType.ExternalEventType]: {
+        type: exports.WorkspaceElementType.ExternalEventType,
+        apiPath: 'external-event-types',
+        collectionName: 'external-event-types',
+        name: 'External Event Type',
+        namePlural: 'External Event Types',
+        isMembraneInterface: true,
+        isIntegrationLevel: true,
+        hasParentChildRelationship: true,
+        parentFieldKey: 'parentId',
+        apiResponseSchema: ExternalEventTypeApiResponse,
+        findQuerySchema: FindExternalEventTypesQuery,
+        editablePropertiesSchema: ExternalEventTypeEditableProperties,
+        exportPropertiesSchema: ExternalEventTypeExportProperties,
+        hasKey: true,
+        hasUuid: true,
+        statsKey: 'externalEventTypes',
+    },
     [exports.WorkspaceElementType.ExternalApiLogRecord]: {
         type: exports.WorkspaceElementType.ExternalApiLogRecord,
         apiPath: 'external-api-logs',
@@ -13567,12 +13844,6 @@ const GenerateWorkspaceAccessTokenRequest = z.z.object({
 const GenerateWorkspaceAccessTokenResponse = z.z.object({
     token: z.z.string().describe('The generated access token'),
 });
-const ListWorkspacesQuery = z.z
-    .object({
-    orgId: z.z.string().optional().describe('Filter workspaces by organization ID'),
-    workspaceKey: z.z.string().optional().describe('Filter workspaces by workspace key'),
-})
-    .merge(IncludeArchivedQuery);
 const GetWorkspaceQuery = IncludeArchivedQuery;
 const MembraneCredentials = z.z.object({
     apiUri: z.z.string().describe('Uri for Membrane API'),
@@ -13637,7 +13908,7 @@ function compareWorkspaceExports(baseExport, targetExport, options = { includeDe
         [exports.WorkspaceElementChangeType.UPDATE]: new Set(),
         [exports.WorkspaceElementChangeType.DELETE]: new Set(),
     };
-    const baseUuidByTargetUuid = new Map();
+    const sourceUuidByTargetUuid = new Map();
     const diffs = [];
     const integrationMap = buildIntegrationsMap([
         ...(baseExport[exports.WorkspaceElementType.Integration] || []),
@@ -13668,7 +13939,7 @@ function compareWorkspaceExports(baseExport, targetExport, options = { includeDe
         const base = baseMap.get(selector);
         const target = targetMap.get(selector);
         if (base && target && base.element.uuid !== target.element.uuid) {
-            baseUuidByTargetUuid.set(target.element.uuid, base.element.uuid);
+            sourceUuidByTargetUuid.set(target.element.uuid, base.element.uuid);
         }
         const change = compareElementExports(base === null || base === void 0 ? void 0 : base.element, target === null || target === void 0 ? void 0 : target.element);
         if (options.includeDeletions === false && (change === null || change === void 0 ? void 0 : change.type) === exports.WorkspaceElementChangeType.DELETE) {
@@ -13688,7 +13959,7 @@ function compareWorkspaceExports(baseExport, targetExport, options = { includeDe
             diffs.push(diff.createTwoFilesPatch(`a/${path}`, `b/${path}`, baseYaml, targetYaml));
         }
     }
-    const result = { comparison, changes, baseUuidByTargetUuid };
+    const result = { comparison, changes, sourceUuidByTargetUuid };
     if (options.includeDiff) {
         result.diff = diffs.join('\n').trim();
     }
@@ -13715,6 +13986,64 @@ function compareElementExports(baseElement, targetElement) {
     }
     return undefined;
 }
+function emptyComparisonResult() {
+    return {
+        comparison: {
+            [exports.WorkspaceElementChangeType.CREATE]: new Set(),
+            [exports.WorkspaceElementChangeType.UPDATE]: new Set(),
+            [exports.WorkspaceElementChangeType.DELETE]: new Set(),
+        },
+        changes: {},
+        sourceUuidByTargetUuid: new Map(),
+    };
+}
+function mergeComparisons(dest, src) {
+    for (const changeType of Object.values(exports.WorkspaceElementChangeType)) {
+        for (const uuid of src.comparison[changeType])
+            dest.comparison[changeType].add(uuid);
+    }
+    Object.assign(dest.changes, src.changes);
+    for (const [k, v] of src.sourceUuidByTargetUuid)
+        dest.sourceUuidByTargetUuid.set(k, v);
+    if (src.diff)
+        dest.diff = dest.diff ? `${dest.diff}\n${src.diff}` : src.diff;
+    return dest;
+}
+function compareElementMaps(baseElements, targetElements, type, options = { includeDeletions: true }) {
+    const changes = {};
+    const comparison = {
+        [exports.WorkspaceElementChangeType.CREATE]: new Set(),
+        [exports.WorkspaceElementChangeType.UPDATE]: new Set(),
+        [exports.WorkspaceElementChangeType.DELETE]: new Set(),
+    };
+    const sourceUuidByTargetUuid = new Map();
+    const diffs = [];
+    const allPaths = new Set([...baseElements.keys(), ...targetElements.keys()]);
+    for (const path of allPaths) {
+        const base = baseElements.get(path);
+        const target = targetElements.get(path);
+        if (base && target && base.uuid !== target.uuid) {
+            sourceUuidByTargetUuid.set(target.uuid, base.uuid);
+        }
+        const change = compareElementExports(base, target);
+        if (options.includeDeletions === false && (change === null || change === void 0 ? void 0 : change.type) === exports.WorkspaceElementChangeType.DELETE)
+            continue;
+        if (!change)
+            continue;
+        changes[change.uuid] = { elementType: type, path };
+        comparison[change.type].add(change.uuid);
+        if (options.includeDiff) {
+            const baseYaml = base ? yaml__namespace.dump(base, { sortKeys: true }) : '';
+            const targetYaml = target ? yaml__namespace.dump(target, { sortKeys: true }) : '';
+            diffs.push(diff.createTwoFilesPatch(`a/${path}`, `b/${path}`, baseYaml, targetYaml));
+        }
+    }
+    const result = { comparison, changes, sourceUuidByTargetUuid };
+    if (options.includeDiff) {
+        result.diff = diffs.join('\n').trim();
+    }
+    return result;
+}
 function getIntegrationIdentifier(element, integrationMap) {
     let integrationIdentifier;
     if (element.integrationUuid) {
@@ -13845,6 +14174,10 @@ const Org = z.z.object({
     engineAutoChargeThreshold: z.z.number().optional(),
     engineAutoChargePurchaseAmount: z.z.number().optional(),
     engineAutoChargeMonthlyLimit: z.z.number().optional(),
+    currentUserCanLeave: z.z
+        .boolean()
+        .optional()
+        .describe('[INTERNAL] Whether the current user can leave this org (false if sole admin)'),
 });
 const EngineCreditsProjectionResponse = z.z.object({
     averageDailyUsage: z.z.number(),
@@ -13890,6 +14223,14 @@ const OrgWorkspace = z.z
     featureFlags: z.z.array(z.z.string()).optional().describe('[INTERNAL] Feature flags'),
     logoUri: z.z.string().optional().describe('URI for the workspace logo'),
     membraneInstanceId: z.z.string().optional().describe('[INTERNAL] Membrane instance ID'),
+    operatorLimits: WorkspaceLimitsSchema.optional().describe('[INTERNAL] Operator-set limit overrides stored on the hub. Mirrored to the instance via PUT /workspaces/:key/limits.'),
+    operatorLimitsSyncedAt: zodDateCoercion()
+        .optional()
+        .describe('[INTERNAL] Last time operatorLimits were successfully mirrored to the owning instance.'),
+    operatorLimitsSyncError: z.z
+        .string()
+        .optional()
+        .describe('[INTERNAL] Last error message from a failed mirror attempt; cleared after a successful sync.'),
 })
     .merge(WorkspaceEditableFields);
 const OrgWorkspaceUpdateRequest = z.z
@@ -13938,6 +14279,7 @@ const CreateOrgRequest = z.z.object({
     integrationApps: z.z.string().optional(),
     firstIntegrationUseCase: z.z.string().optional(),
     referralSource: z.z.string().optional(),
+    useCase: z.z.string().max(1024).optional(),
     builder: z.z.array(z.z.enum(['me', 'team'])).optional(),
     stripeCustomerId: z.z.string().optional(),
     signupSource: z.z.string().optional(),
@@ -14180,6 +14522,14 @@ class ElementInstanceAccessor {
     }
 }
 
+const warned = new Set();
+function warnDeprecatedOnce(key, message) {
+    if (warned.has(key))
+        return;
+    warned.add(key);
+    console.warn(`[Membrane deprecation] ${message}`);
+}
+
 class ConnectionLevelElementAccessor {
     constructor(client, connectionSelector, selector, elementKey, query) {
         this.client = client;
@@ -14288,6 +14638,7 @@ class ActionAccessor extends ElementAccessor {
         return await this.options.client.post(this.getPath('reset'));
     }
     async run(input, options) {
+        warnDeprecatedOnce('ActionAccessor.run', 'ActionAccessor.run() is deprecated. Use POST /act with { action: { id } } or { integrationKey, key } instead.');
         const queryParams = options
             ? {
                 integrationKey: options.integrationKey,
@@ -14322,6 +14673,7 @@ class ConnectionLevelActionAccessor extends ConnectionLevelElementAccessor {
         this.query = query;
     }
     async run(input) {
+        warnDeprecatedOnce('ConnectionLevelActionAccessor.run', 'ConnectionLevelActionAccessor.run() is deprecated. Use POST /act with { action: { id } } or { integrationKey, key } instead.');
         return this.client.post(this.uri('/run'), input);
     }
 }
@@ -14791,6 +15143,64 @@ async function openIframeWithPost(url, postData, callbacks = {}, { mountTargetSe
     });
 }
 
+function routeConnectionEventMessage(message, requestId, handlers) {
+    var _a, _b, _c, _d, _e;
+    if (!isConnectionMessagePayload(message))
+        return;
+    if (message.requestId && message.requestId !== requestId)
+        return;
+    if (message.type === 'newConnectionCreated') {
+        (_a = handlers.onSuccess) === null || _a === void 0 ? void 0 : _a.call(handlers, message.connection);
+        (_b = handlers.onTerminal) === null || _b === void 0 ? void 0 : _b.call(handlers);
+        return;
+    }
+    if (message.type === 'newConnectionFailure') {
+        const error = new MembraneError((_c = message.errorData) !== null && _c !== void 0 ? _c : message.error);
+        if (message.connectionId) {
+            error.data.data = { ...error.data.data, connectionId: message.connectionId };
+        }
+        (_d = handlers.onFailure) === null || _d === void 0 ? void 0 : _d.call(handlers, error);
+        (_e = handlers.onTerminal) === null || _e === void 0 ? void 0 : _e.call(handlers);
+    }
+}
+function isConnectionMessagePayload(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const m = value;
+    return m.source === 'integration.app' && typeof m.type === 'string';
+}
+function createConnectionEventsSubscription(options) {
+    const { apiUri, getToken, requestId, handlers } = options;
+    let eventSource = null;
+    let cancelled = false;
+    const close = () => {
+        cancelled = true;
+        eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
+        eventSource = null;
+    };
+    Promise.resolve(getToken()).then((token) => {
+        if (cancelled)
+            return;
+        const url = urljoin(apiUri, '/sse/connection-events', requestId) + `?token=${encodeURIComponent(token)}`;
+        try {
+            eventSource = new EventSource(url);
+            eventSource.onmessage = (event) => {
+                let data;
+                try {
+                    data = JSON.parse(event.data);
+                }
+                catch (_a) {
+                    return;
+                }
+                routeConnectionEventMessage(data, requestId, handlers);
+            };
+            eventSource.onerror = close;
+        }
+        catch (_a) { }
+    });
+    return close;
+}
+
 class DataSourcesAccessor extends ElementListAccessor {
     constructor(client) {
         super(client, 'data-sources');
@@ -15251,6 +15661,9 @@ class ConnectionAccessor {
     async archive() {
         return this.client.delete(`/connections/${this.connectionSelector}`);
     }
+    async restore() {
+        return this.client.post(`/connections/${this.connectionSelector}/restore`);
+    }
     async request(path, data = null) {
         const pathWithoutSlash = path.startsWith('/') ? path.slice(1) : path;
         return this.client.post(`/connections/${this.connectionSelector}/api/${pathWithoutSlash}`, data);
@@ -15362,7 +15775,7 @@ class ConnectionProxy {
     }
 }
 async function createOrUpdateConnection(options) {
-    const { client, connectionId, connectionKey, integrationKey, integrationId, connectorId, connectorVersion, name, input, connectorParameters, allowMultipleConnections, authOptionKey, connectionRequestId, apiUri, redirectUri, onPopupClosed, } = options !== null && options !== void 0 ? options : {};
+    const { client, connectionId, connectionKey, integrationKey, integrationId, connectorId, connectorVersion, name, input, connectorParameters, allowMultipleConnections, authOptionKey, connectionRequestId, apiUri, redirectUri, onPopupClosed, lateEvents, } = options !== null && options !== void 0 ? options : {};
     let connectionType = await detectConnectionType(options);
     if (redirectUri) {
         connectionType = ConnectionType.REDIRECT;
@@ -15370,6 +15783,7 @@ async function createOrUpdateConnection(options) {
     const freshToken = await client.getToken();
     const connectPath = 'connect';
     return new Promise((resolve, reject) => {
+        var _a, _b;
         const requestId = simpleUniqueId() + simpleUniqueId();
         const payload = {
             token: freshToken,
@@ -15389,24 +15803,51 @@ async function createOrUpdateConnection(options) {
             redirectUri,
         };
         let cancelCheckInterval;
-        const eventHandler = createConnectionEventHandler(requestId, (data) => {
-            resolve(data);
-        }, (error) => {
-            reject(error);
-        }, () => {
-            cleanup();
-        });
-        const { stopCrossWindow } = createCrossWindowListener({
-            handler: eventHandler,
-        });
-        const { stopSSE } = createSSEListener({
+        let lateEventsTimeout;
+        let promiseSettled = false;
+        const handlers = {
+            onSuccess: (data) => {
+                var _a;
+                if (promiseSettled) {
+                    (_a = lateEvents === null || lateEvents === void 0 ? void 0 : lateEvents.onConnection) === null || _a === void 0 ? void 0 : _a.call(lateEvents, data);
+                }
+                else {
+                    promiseSettled = true;
+                    resolve(data);
+                }
+            },
+            onFailure: (error) => {
+                var _a;
+                if (promiseSettled) {
+                    (_a = lateEvents === null || lateEvents === void 0 ? void 0 : lateEvents.onFailure) === null || _a === void 0 ? void 0 : _a.call(lateEvents, error);
+                }
+                else {
+                    promiseSettled = true;
+                    reject(error);
+                }
+            },
+            onTerminal: () => cleanup(),
+        };
+        const { stopCrossWindow } = createCrossWindowListener({ requestId, handlers });
+        const stopSSE = createConnectionEventsSubscription({
             apiUri: apiUri,
+            getToken: () => freshToken,
             requestId,
-            token: freshToken,
-            handler: eventHandler,
+            handlers,
         });
+        if (lateEvents) {
+            lateEventsTimeout = setTimeout(stopSSE, 30 * 60 * 1000);
+            if ((_a = lateEvents.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                stopSSE();
+            }
+            else {
+                (_b = lateEvents.signal) === null || _b === void 0 ? void 0 : _b.addEventListener('abort', stopSSE, { once: true });
+            }
+        }
         function cleanup() {
             clearInterval(cancelCheckInterval);
+            if (lateEventsTimeout)
+                clearTimeout(lateEventsTimeout);
             stopCrossWindow();
             stopSSE();
         }
@@ -15464,9 +15905,15 @@ async function createOrUpdateConnection(options) {
                 }, 1000);
                 cancelCheckInterval = setInterval(() => {
                     if (popup === null || popup === void 0 ? void 0 : popup.closed) {
-                        cleanup();
-                        onPopupClosed === null || onPopupClosed === void 0 ? void 0 : onPopupClosed();
-                        resolve(null);
+                        clearInterval(cancelCheckInterval);
+                        stopCrossWindow();
+                        if (!lateEvents)
+                            stopSSE();
+                        if (!promiseSettled) {
+                            promiseSettled = true;
+                            onPopupClosed === null || onPopupClosed === void 0 ? void 0 : onPopupClosed();
+                            resolve(null);
+                        }
                     }
                 }, 1000);
             }
@@ -15490,60 +15937,17 @@ async function detectConnectionType({ client, authOptionKey, connectorId, connec
     }
     return ConnectionType.POPUP;
 }
-const createConnectionEventHandler = (requestId, onResolve, onReject, onFinally) => {
-    return (event) => {
-        var _a;
-        const message = event.data || {};
-        if (message.source == 'integration.app' && (message.requestId == requestId || !message.requestId)) {
-            if (message.type == 'newConnectionCreated') {
-                onResolve(message.connection);
-            }
-            if (message.type == 'newConnectionFailure') {
-                const error = new MembraneError((_a = message.errorData) !== null && _a !== void 0 ? _a : message.error);
-                if (message.connectionId) {
-                    error.data.data = { ...error.data.data, connectionId: message.connectionId };
-                }
-                onReject(error);
-            }
-            onFinally();
-        }
+const createCrossWindowListener = ({ requestId, handlers, }) => {
+    const listener = (event) => {
+        routeConnectionEventMessage(event.data, requestId, handlers);
     };
-};
-const createCrossWindowListener = ({ handler }) => {
-    window.addEventListener('message', handler);
+    window.addEventListener('message', listener);
     return {
         stopCrossWindow: () => {
-            window.removeEventListener('message', handler);
+            window.removeEventListener('message', listener);
         },
     };
 };
-const createSSEListener = ({ apiUri, requestId, token, handler, }) => {
-    const sseUrl = urljoin(apiUri, '/sse/connection-events', requestId) + `?token=${encodeURIComponent(token)}`;
-    let eventSource = null;
-    const closeSseConnection = () => {
-        eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
-        eventSource = null;
-    };
-    try {
-        eventSource = new EventSource(sseUrl);
-        eventSource.onmessage = (event) => {
-            const eventCopy = {
-                ...event,
-                data: JSON.parse(event.data),
-            };
-            handler(eventCopy);
-        };
-        eventSource.onerror = () => {
-            closeSseConnection();
-        };
-    }
-    catch (err) {
-        console.error('Error setting up SSE connection:', err);
-    }
-    return {
-        stopSSE: closeSseConnection,
-    };
-};
 
 class FlowsAccessor extends ElementListAccessor {
     constructor(client) {
@@ -16036,7 +16440,7 @@ const SessionParameters = z.z.object({
     credentials: SessionCredentials.optional(),
     apiUri: z.z.string().optional(),
     prompt: z.z.string().optional(),
-    elementType: z.z.string().optional(),
+    elementType: z.z.enum(exports.WorkspaceElementType).optional(),
     elementId: z.z.string().optional(),
     customerId: z.z.string().optional(),
     opencodeSessionUuid: z.z.string().optional(),
@@ -16060,6 +16464,29 @@ const AsyncRequestTriggerResponse = z.z.object({
     jobId: z.z.string(),
     accessKey: z.z.string(),
 });
+const ListableAsyncRequestType = z.z.enum(['export-workspace', 'import-workspace']);
+const AsyncRequestStatusSchema = z.z.nativeEnum(exports.AsyncRequestStatus);
+const AsyncRequest = z.z.object({
+    id: z.z.string(),
+    requestType: ListableAsyncRequestType,
+    status: AsyncRequestStatusSchema,
+    progress: z.z.number().optional(),
+    result: z.z.record(z.z.string(), z.z.any()).optional(),
+    error: ErrorDataSchema.optional(),
+    meta: z.z.record(z.z.string(), z.z.any()).optional(),
+    createdAt: zodDateCoercion(),
+    startedAt: zodDateCoercion().optional(),
+    completedAt: zodDateCoercion().optional(),
+});
+const ListAsyncRequestsQuery = z.z.object({
+    requestType: ListableAsyncRequestType,
+    status: AsyncRequestStatusSchema.optional(),
+    limit: z.z.coerce.number().int().min(1).max(100).default(50),
+    cursor: z.z.coerce.number().int().min(0).optional(),
+});
+const ListAsyncRequestsResponse = z.z.object({
+    items: z.z.array(AsyncRequest),
+});
 
 const SelfHostingToken = z.z.object({
     id: z.z.string(),
@@ -16086,33 +16513,6 @@ const ValidateSelfHostingTokenResponse = z.z.object({
     orgName: z.z.string().optional(),
 });
 
-const CLIENT_TOKEN_GRANT_TYPES = ['mcp-oauth', 'cli-oauth', 'agent-session', 'api'];
-const ClientTokenGrantType = z.z.enum(CLIENT_TOKEN_GRANT_TYPES);
-const ClientToken = z.z.object({
-    id: z.z.string(),
-    workspaceId: z.z.string().optional(),
-    platformUserId: z.z.string().optional(),
-    tenantId: z.z.string().optional(),
-    grantType: ClientTokenGrantType,
-    grantId: z.z.string().optional(),
-    grantName: z.z.string().optional(),
-    connectedProductId: z.z.string().optional(),
-    createdAt: z.z.string(),
-});
-const CreateClientTokenResponse = ClientToken.extend({
-    accessToken: z.z.string(),
-});
-const CreateClientTokenRequest = z.z.object({
-    grantType: ClientTokenGrantType,
-    grantId: z.z.string(),
-    grantName: z.z.string(),
-    tenantId: z.z.string().optional(),
-    clientKey: z.z.string().optional(),
-});
-const ClientTokenListResponse = z.z.object({
-    items: z.z.array(ClientToken),
-});
-
 const MEMBRANE_CLI_CLIENT_ID = 'membrane-cli';
 const OAUTH_TOKEN_TYPE_PLATFORM_USER = 'platform-user';
 const OAUTH_TOKEN_TYPE_TENANT = 'tenant';
@@ -16122,6 +16522,20 @@ const OAUTH_TOKEN_TYPES = [
     OAUTH_TOKEN_TYPE_TENANT,
     OAUTH_TOKEN_TYPE_CONNECTION,
 ];
+const AuthContextSettings = z.z.object({
+    defaultWorkspaceKey: z.z.string().optional(),
+    defaultTenantKey: z.z.string().optional(),
+    connectionId: z.z.string().optional(),
+});
+const PatchTokenSettingsRequest = z.z.object({
+    settings: z.z
+        .object({
+        defaultWorkspaceKey: z.z.string().nullable().optional(),
+        defaultTenantKey: z.z.string().nullable().optional(),
+        connectionId: z.z.string().nullable().optional(),
+    })
+        .optional(),
+});
 const OAuthTokenResponse = z.z.object({
     access_token: z.z.string(),
     token_type: z.z.string(),
@@ -16133,6 +16547,51 @@ const OAuthTokenResponse = z.z.object({
     org_id: z.z.string().optional(),
 });
 
+const PLATFORM_USER_TOKEN_GRANT_TYPES = ['cli-oauth'];
+const PlatformUserTokenGrantType = z.z.enum(PLATFORM_USER_TOKEN_GRANT_TYPES);
+const PlatformUserToken = z.z.object({
+    id: z.z.string(),
+    platformUserId: z.z.string(),
+    grantType: PlatformUserTokenGrantType,
+    grantId: z.z.string().optional(),
+    grantName: z.z.string().optional(),
+    settings: AuthContextSettings.optional(),
+    createdAt: z.z.string(),
+    lastUsedDate: z.z.string().optional(),
+});
+const PlatformUserTokenListResponse = z.z.object({
+    items: z.z.array(PlatformUserToken),
+});
+
+const WORKSPACE_TOKEN_GRANT_TYPES = ['mcp-oauth', 'agent-session', 'api'];
+const WorkspaceTokenGrantType = z.z.enum(WORKSPACE_TOKEN_GRANT_TYPES);
+const WorkspaceToken = z.z.object({
+    id: z.z.string(),
+    workspaceId: z.z.string(),
+    tenantId: z.z.string().optional(),
+    platformUserId: z.z.string().optional(),
+    grantType: WorkspaceTokenGrantType,
+    grantId: z.z.string().optional(),
+    grantName: z.z.string().optional(),
+    connectedProductId: z.z.string().optional(),
+    settings: AuthContextSettings.optional(),
+    createdAt: z.z.string(),
+    lastUsedDate: z.z.string().optional(),
+});
+const CreateWorkspaceTokenResponse = WorkspaceToken.extend({
+    accessToken: z.z.string(),
+});
+const CreateWorkspaceTokenRequest = z.z.object({
+    grantType: WorkspaceTokenGrantType,
+    grantId: z.z.string(),
+    grantName: z.z.string(),
+    tenantId: z.z.string().optional(),
+    clientKey: z.z.string().optional(),
+});
+const WorkspaceTokenListResponse = z.z.object({
+    items: z.z.array(WorkspaceToken),
+});
+
 const CONSOLE_ACCOUNT_API_TOKEN_PATH = 'settings/account/api-token';
 
 const PendingQueueCountSchema = z.z.object({
@@ -16768,6 +17227,7 @@ exports.AccountResponse = AccountResponse;
 exports.ActApiDispatch = ActApiDispatch;
 exports.ActRequest = ActRequest;
 exports.ActionAccessor = ActionAccessor;
+exports.ActionApiPayload = ActionApiPayload;
 exports.ActionApiResponse = ActionApiResponse;
 exports.ActionDependency = ActionDependency;
 exports.ActionEditableProperties = ActionEditableProperties;
@@ -16780,6 +17240,7 @@ exports.ActionRunError = ActionRunError;
 exports.ActionRunLogRecordApiResponse = ActionRunLogRecordApiResponse;
 exports.ActionRunResponse = ActionRunResponse;
 exports.ActionRunsStatsQuery = ActionRunsStatsQuery;
+exports.ActionSnapshot = ActionSnapshot;
 exports.ActionsAccessor = ActionsAccessor;
 exports.ActivityLogRecord = ActivityLogRecord;
 exports.ActivityStatsQuery = ActivityStatsQuery;
@@ -16814,8 +17275,11 @@ exports.AppEventTypeExportProperties = AppEventTypeExportProperties;
 exports.AppEventTypesAccessor = AppEventTypesAccessor;
 exports.AppSchema = AppSchema;
 exports.AppliedToIntegrations = AppliedToIntegrations;
+exports.AsyncRequest = AsyncRequest;
+exports.AsyncRequestStatusSchema = AsyncRequestStatusSchema;
 exports.AsyncRequestTriggerResponse = AsyncRequestTriggerResponse;
 exports.AuthContextPermissionsSchema = AuthContextPermissionsSchema;
+exports.AuthContextSettings = AuthContextSettings;
 exports.BackwardCompatibleDataSourceEditableProperties = BackwardCompatibleDataSourceEditableProperties;
 exports.BadRequestError = BadRequestError;
 exports.BaseAction = BaseAction;
@@ -16834,10 +17298,12 @@ exports.BaseDataLinkTable = BaseDataLinkTable;
 exports.BaseDataLinkTableInstance = BaseDataLinkTableInstance;
 exports.BaseDataSource = BaseDataSource;
 exports.BaseDataSourceInstance = BaseDataSourceInstance;
+exports.BaseExportProperties = BaseExportProperties;
 exports.BaseExternalEvent = BaseExternalEvent;
 exports.BaseExternalEventLogRecord = BaseExternalEventLogRecord;
 exports.BaseExternalEventPull = BaseExternalEventPull;
 exports.BaseExternalEventSubscription = BaseExternalEventSubscription;
+exports.BaseExternalEventType = BaseExternalEventType;
 exports.BaseFieldMapping = BaseFieldMapping;
 exports.BaseFieldMappingInstance = BaseFieldMappingInstance;
 exports.BaseFlow = BaseFlow;
@@ -16856,7 +17322,6 @@ exports.BaseOrgUser = BaseOrgUser;
 exports.BasePackage = BasePackage;
 exports.BaseScreen = BaseScreen;
 exports.BaseWorkspaceElement = BaseWorkspaceElement;
-exports.CLIENT_TOKEN_GRANT_TYPES = CLIENT_TOKEN_GRANT_TYPES;
 exports.CONNECTION_REQUEST_ID_PARAM = CONNECTION_REQUEST_ID_PARAM;
 exports.CONNECTION_REQUEST_SCREEN_PATH = CONNECTION_REQUEST_SCREEN_PATH;
 exports.CONNECTOR_AUTH_TYPES = CONNECTOR_AUTH_TYPES;
@@ -16873,9 +17338,6 @@ exports.CONSOLE_ACCOUNT_API_TOKEN_PATH = CONSOLE_ACCOUNT_API_TOKEN_PATH;
 exports.CheckpointApiResponse = CheckpointApiResponse;
 exports.CheckpointDiffOperationSchema = CheckpointDiffOperationSchema;
 exports.CheckpointDiffResponseSchema = CheckpointDiffResponseSchema;
-exports.ClientToken = ClientToken;
-exports.ClientTokenGrantType = ClientTokenGrantType;
-exports.ClientTokenListResponse = ClientTokenListResponse;
 exports.CommonFindElementsQuery = CommonFindElementsQuery;
 exports.CommonFindInstancesQuery = CommonFindInstancesQuery;
 exports.CommonInstancesListQuery = CommonInstancesListQuery;
@@ -16895,6 +17357,7 @@ exports.ConnectionAttemptLogApiResponse = ConnectionAttemptLogApiResponse;
 exports.ConnectionClientAction = ConnectionClientAction;
 exports.ConnectionDataCollectionAccessor = ConnectionDataCollectionAccessor;
 exports.ConnectionEditableProperties = ConnectionEditableProperties;
+exports.ConnectionEntityMessagePayload = ConnectionEntityMessagePayload;
 exports.ConnectionError = ConnectionError;
 exports.ConnectionExportProperties = ConnectionExportProperties;
 exports.ConnectionLevelActionAccessor = ConnectionLevelActionAccessor;
@@ -16958,8 +17421,6 @@ exports.CreateActionInstanceRequest = CreateActionInstanceRequest;
 exports.CreateActionRequest = CreateActionRequest;
 exports.CreateAgentSession = CreateAgentSession;
 exports.CreateAlert = CreateAlert;
-exports.CreateClientTokenRequest = CreateClientTokenRequest;
-exports.CreateClientTokenResponse = CreateClientTokenResponse;
 exports.CreateConnectedProductRequest = CreateConnectedProductRequest;
 exports.CreateConnectionRequest = CreateConnectionRequest;
 exports.CreateConnectionRequestPayload = CreateConnectionRequestPayload;
@@ -16968,6 +17429,9 @@ exports.CreateCustomerRequest = CreateCustomerRequest;
 exports.CreateDataLinkTableRequest = CreateDataLinkTableRequest;
 exports.CreateDataSourceInstanceRequest = CreateDataSourceInstanceRequest;
 exports.CreateDataSourceRequest = CreateDataSourceRequest;
+exports.CreateExternalAppRequest = CreateExternalAppRequest;
+exports.CreateExternalEventSubscriptionRequest = CreateExternalEventSubscriptionRequest;
+exports.CreateExternalEventTypeRequest = CreateExternalEventTypeRequest;
 exports.CreateFieldMappingInstanceRequest = CreateFieldMappingInstanceRequest;
 exports.CreateFieldMappingRequest = CreateFieldMappingRequest;
 exports.CreateFlowNodeRequest = CreateFlowNodeRequest;
@@ -16984,6 +17448,8 @@ exports.CreateScreenRequest = CreateScreenRequest;
 exports.CreateSelfHostingTokenRequest = CreateSelfHostingTokenRequest;
 exports.CreateSelfHostingTokenResponse = CreateSelfHostingTokenResponse;
 exports.CreateWorkspaceRequest = CreateWorkspaceRequest;
+exports.CreateWorkspaceTokenRequest = CreateWorkspaceTokenRequest;
+exports.CreateWorkspaceTokenResponse = CreateWorkspaceTokenResponse;
 exports.CustomCodeError = CustomCodeError;
 exports.CustomerAccessor = CustomerAccessor;
 exports.CustomerApiResponse = CustomerApiResponse;
@@ -17080,6 +17546,7 @@ exports.DependencyError = DependencyError;
 exports.DomainFromEmail = DomainFromEmail;
 exports.DownstreamFlowNodeRunSchema = DownstreamFlowNodeRunSchema;
 exports.EDITABLE_LIMITS = EDITABLE_LIMITS;
+exports.EXTERNAL_EVENT_TYPE_FUNCTION_KEYS = EXTERNAL_EVENT_TYPE_FUNCTION_KEYS;
 exports.ElementAccessor = ElementAccessor;
 exports.ElementInstanceAccessor = ElementInstanceAccessor;
 exports.ElementInstanceListAccessor = ElementInstanceListAccessor;
@@ -17099,6 +17566,9 @@ exports.ExternalEventSubscriptionAccessor = ExternalEventSubscriptionAccessor;
 exports.ExternalEventSubscriptionApiResponse = ExternalEventSubscriptionApiResponse;
 exports.ExternalEventSubscriptionConfig = ExternalEventSubscriptionConfig;
 exports.ExternalEventSubscriptionsAccessor = ExternalEventSubscriptionsAccessor;
+exports.ExternalEventTypeApiResponse = ExternalEventTypeApiResponse;
+exports.ExternalEventTypeEditableProperties = ExternalEventTypeEditableProperties;
+exports.ExternalEventTypeExportProperties = ExternalEventTypeExportProperties;
 exports.ExternalEventUnitConfig = ExternalEventUnitConfig;
 exports.FLOW_NODE_SPECS = FLOW_NODE_SPECS;
 exports.FieldMappingAccessor = FieldMappingAccessor;
@@ -17138,6 +17608,7 @@ exports.FindDataSourceInstancesQuery = FindDataSourceInstancesQuery;
 exports.FindDataSourceSyncsQuery = FindDataSourceSyncsQuery;
 exports.FindDataSourcesQuery = FindDataSourcesQuery;
 exports.FindExternalEventPullsQuery = FindExternalEventPullsQuery;
+exports.FindExternalEventTypesQuery = FindExternalEventTypesQuery;
 exports.FindFieldMappingInstancesQuery = FindFieldMappingInstancesQuery;
 exports.FindFieldMappingsQuery = FindFieldMappingsQuery;
 exports.FindFlowInstancesQuery = FindFlowInstancesQuery;
@@ -17229,6 +17700,9 @@ exports.JavascriptFunction = JavascriptFunction;
 exports.JsonataFormula = JsonataFormula;
 exports.ListActionInstancesForConnectionQuery = ListActionInstancesForConnectionQuery;
 exports.ListAppEventLogRecordsQuery = ListAppEventLogRecordsQuery;
+exports.ListAsyncRequestsQuery = ListAsyncRequestsQuery;
+exports.ListAsyncRequestsResponse = ListAsyncRequestsResponse;
+exports.ListConnectorsQuery = ListConnectorsQuery;
 exports.ListDataSourceInstancesForConnectionQuery = ListDataSourceInstancesForConnectionQuery;
 exports.ListExternalApiLogsQuery = ListExternalApiLogsQuery;
 exports.ListExternalAppsQuery = ListExternalAppsQuery;
@@ -17243,7 +17717,7 @@ exports.ListOrgWorkspacesQuery = ListOrgWorkspacesQuery;
 exports.ListOrgWorkspacesResponse = ListOrgWorkspacesResponse;
 exports.ListPublicConnectorsQuery = ListPublicConnectorsQuery;
 exports.ListPublicPackagesQuery = ListPublicPackagesQuery;
-exports.ListWorkspacesQuery = ListWorkspacesQuery;
+exports.ListableAsyncRequestType = ListableAsyncRequestType;
 exports.MEMBRANE_CLI_CLIENT_ID = MEMBRANE_CLI_CLIENT_ID;
 exports.MEMBRANE_ELEMENT_CONFIG_FILE_NAME = MEMBRANE_ELEMENT_CONFIG_FILE_NAME;
 exports.MEMBRANE_SESSION_ID_HEADER = MEMBRANE_SESSION_ID_HEADER;
@@ -17287,6 +17761,7 @@ exports.OrgWorkspaceUser = OrgWorkspaceUser;
 exports.PACKAGE_VERSION_DEVELOPMENT = PACKAGE_VERSION_DEVELOPMENT;
 exports.PACKAGE_VERSION_LATEST = PACKAGE_VERSION_LATEST;
 exports.PARALLEL_EXECUTION_LIMITS = PARALLEL_EXECUTION_LIMITS;
+exports.PLATFORM_USER_TOKEN_GRANT_TYPES = PLATFORM_USER_TOKEN_GRANT_TYPES;
 exports.PackageAccessor = PackageAccessor;
 exports.PackageApiResponse = PackageApiResponse;
 exports.PackageCalculatedProperties = PackageCalculatedProperties;
@@ -17302,13 +17777,19 @@ exports.PaginationQuery = PaginationQuery;
 exports.PaginationResponse = PaginationResponse;
 exports.PatchAgentSessionSchema = PatchAgentSessionSchema;
 exports.PatchConnectionRequestPayload = PatchConnectionRequestPayload;
+exports.PatchExternalEventSubscriptionRequest = PatchExternalEventSubscriptionRequest;
+exports.PatchTokenSettingsRequest = PatchTokenSettingsRequest;
 exports.PatchUserWorkspaceSettings = PatchUserWorkspaceSettings;
 exports.PendingQueueCountSchema = PendingQueueCountSchema;
 exports.PendingTasksSummarySchema = PendingTasksSummarySchema;
 exports.PlatformUser = PlatformUser;
+exports.PlatformUserToken = PlatformUserToken;
+exports.PlatformUserTokenGrantType = PlatformUserTokenGrantType;
+exports.PlatformUserTokenListResponse = PlatformUserTokenListResponse;
 exports.RATE_LIMITS = RATE_LIMITS;
 exports.REFERENCE_ELEMENT_TYPE_SELF = REFERENCE_ELEMENT_TYPE_SELF;
 exports.RateLimitExceededError = RateLimitExceededError;
+exports.RemoteConnectorCodeUnavailableError = RemoteConnectorCodeUnavailableError;
 exports.RequestMappingSchema = RequestMappingSchema;
 exports.ResetFlowInstanceOptions = ResetFlowInstanceOptions;
 exports.RestApiMappingFunction = RestApiMappingFunction;
@@ -17347,6 +17828,8 @@ exports.UpdateCustomerRequest = UpdateCustomerRequest;
 exports.UpdateDataLinkTableRequest = UpdateDataLinkTableRequest;
 exports.UpdateDataSourceInstanceRequest = UpdateDataSourceInstanceRequest;
 exports.UpdateDataSourceRequest = UpdateDataSourceRequest;
+exports.UpdateExternalAppRequest = UpdateExternalAppRequest;
+exports.UpdateExternalEventTypeRequest = UpdateExternalEventTypeRequest;
 exports.UpdateFieldMappingInstanceRequest = UpdateFieldMappingInstanceRequest;
 exports.UpdateFieldMappingRequest = UpdateFieldMappingRequest;
 exports.UpdateFlowRequest = UpdateFlowRequest;
@@ -17369,6 +17852,7 @@ exports.WORKSPACE_DATABASE_RECORD_COLLECTIONS = WORKSPACE_DATABASE_RECORD_COLLEC
 exports.WORKSPACE_ELEMENTS_STATS_COLLECTIONS = WORKSPACE_ELEMENTS_STATS_COLLECTIONS;
 exports.WORKSPACE_ELEMENT_COLLECTIONS = WORKSPACE_ELEMENT_COLLECTIONS;
 exports.WORKSPACE_SIZE_LIMITS = WORKSPACE_SIZE_LIMITS;
+exports.WORKSPACE_TOKEN_GRANT_TYPES = WORKSPACE_TOKEN_GRANT_TYPES;
 exports.Workspace = Workspace;
 exports.WorkspaceEditableFields = WorkspaceEditableFields;
 exports.WorkspaceElementSearchQuery = WorkspaceElementSearchQuery;
@@ -17379,6 +17863,9 @@ exports.WorkspaceLimitsSchema = WorkspaceLimitsSchema;
 exports.WorkspaceOnboardingData = WorkspaceOnboardingData;
 exports.WorkspacePublicKey = WorkspacePublicKey;
 exports.WorkspaceSettingsSchema = WorkspaceSettingsSchema;
+exports.WorkspaceToken = WorkspaceToken;
+exports.WorkspaceTokenGrantType = WorkspaceTokenGrantType;
+exports.WorkspaceTokenListResponse = WorkspaceTokenListResponse;
 exports.WritableConnectorVersionData = WritableConnectorVersionData;
 exports.WritablePackageVersionData = WritablePackageVersionData;
 exports.WriteableConnectorFields = WriteableConnectorFields;
@@ -17388,11 +17875,14 @@ exports.addRequiredFieldsToSchema = addRequiredFieldsToSchema;
 exports.addUdmFallbackFields = addUdmFallbackFields;
 exports.addUndefinedWriteableProperties = addUndefinedWriteableProperties;
 exports.backwardCompatibleFilterMatch = backwardCompatibleFilterMatch;
+exports.buildActionSnapshot = buildActionSnapshot;
 exports.buildData = buildData;
 exports.buildDataSchema = buildDataSchema;
 exports.buildValue = buildValue;
+exports.compareElementMaps = compareElementMaps;
 exports.compareWorkspaceExports = compareWorkspaceExports;
 exports.compressDataSchema = compressDataSchema;
+exports.configToNamedPayload = configToNamedPayload;
 exports.createCompoundSchema = createCompoundSchema;
 exports.createFlowInstanceSchema = createFlowInstanceSchema;
 exports.createObjectFromLocators = createObjectFromLocators;
@@ -17402,6 +17892,7 @@ exports.createSchema = createSchema;
 exports.dataCollectionEventTypeToExternalEventType = dataCollectionEventTypeToExternalEventType;
 exports.dataLocationParametersMatch = dataLocationParametersMatch;
 exports.doesMatchFilter = doesMatchFilter;
+exports.emptyComparisonResult = emptyComparisonResult;
 exports.excludeFieldsFromSchema = excludeFieldsFromSchema;
 exports.excludeFieldsFromValue = excludeFieldsFromValue;
 exports.excludeReadOnlyFieldsFromSchema = excludeReadOnlyFieldsFromSchema;
@@ -17503,6 +17994,7 @@ exports.makeDataLocationPath = makeDataLocationPath;
 exports.makeDataRecordSchema = makeDataRecordSchema;
 exports.makeObjectPropertyLocator = makeObjectPropertyLocator;
 exports.makeSchemaForLocator = makeSchemaForLocator;
+exports.mergeComparisons = mergeComparisons;
 exports.mergeSchemas = mergeSchemas;
 exports.mergeWithFormulas = mergeWithFormulas;
 exports.nonEmptyObjectProperties = nonEmptyObjectProperties;