@membranehq/sdk 0.9.11 → 0.11.0

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

@@ -6,13 +6,13 @@ import { ConnectionLevelFlowAccessor, ConnectionLevelFlowsAccessor } from './flo
 import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
 import { InstanceKeyQuery } from '../integration-elements/common';
-import { Connection, CreateConnectionRequest, FindConnectionsQuery, UpdateConnectionRequest } from '../workspace-elements/api/connections-api';
+import { ConnectionApiResponse, CreateConnectionRequest, FindConnectionsQuery, UpdateConnectionRequest } from '../workspace-elements/api/connections-api';
 import { ConnectorSpec } from '../workspace-elements/base/connectors';
 import { OperationRunRequest, OperationRunResponse, OperationSpec } from '../workspace-elements/base/connectors/operations/types';
 import { DataCollectionSpec, DataCollectionCreateRequest, DataCollectionCreateResponse, DataCollectionDeleteRequest, DataCollectionDeleteResponse, DataCollectionFindByIdRequest, DataCollectionFindByIdResponse, DataCollectionListRequest, DataCollectionListResponse, DataCollectionMatchRequest, DataCollectionMatchResponse, DataCollectionSearchRequest, DataCollectionSearchResponse, DataCollectionUpdateRequest, DataCollectionUpdateResponse } from '../workspace-elements/base/data-collections';
-export declare class ConnectionsAccessor extends ElementInstanceListAccessor<Connection, FindConnectionsQuery> {
+export declare class ConnectionsAccessor extends ElementInstanceListAccessor<ConnectionApiResponse, FindConnectionsQuery> {
     constructor(client: MembraneApiClient);
-    create(data: CreateConnectionRequest): Promise<Connection>;
+    create(data: CreateConnectionRequest): Promise<ConnectionApiResponse>;
 }
 export declare class ConnectionAccessor {
     client: MembraneApiClient;
@@ -28,23 +28,23 @@ export declare class ConnectionAccessor {
     fieldMapping(fieldMappingSelector: string, query?: InstanceKeyQuery): ConnectionLevelFieldMappingAccessor;
     get(query?: {
         includeSecrets?: boolean;
-    }): Promise<Connection>;
-    patch(data: UpdateConnectionRequest): Promise<Connection>;
-    put(data: UpdateConnectionRequest): Promise<Connection>;
+    }): Promise<ConnectionApiResponse>;
+    patch(data: UpdateConnectionRequest): Promise<ConnectionApiResponse>;
+    put(data: UpdateConnectionRequest): Promise<ConnectionApiResponse>;
     archive(): Promise<void>;
     request(path: string, data?: any): Promise<any>;
     get proxy(): ConnectionProxy;
     operation(key: string): ConnectionOperationAccessor;
     dataCollection(key: string, parameters?: Record<string, any>): ConnectionDataCollectionAccessor;
-    reconnect({ parameters, authOptionKey, connectorParameters, }?: {
+    reconnect({ parameters, authOptionKey, connectorParameters, onPopupClosed, }?: {
         parameters?: any;
         authOptionKey?: string;
         connectorParameters?: any;
+        onPopupClosed?: () => void;
     }): Promise<{
         id: string;
         name: string;
         userId: string;
-        integrationId: string;
         createdAt: string;
         updatedAt: string;
         isTest?: boolean | undefined;
@@ -52,6 +52,9 @@ export declare class ConnectionAccessor {
         isDefunct?: boolean | undefined;
         state?: import("../workspace-elements").WorkspaceElementState | undefined;
         error?: import("../errors").ErrorDataSchema | undefined;
+        integrationId?: string | undefined;
+        connectorId?: string | undefined;
+        connectorVersion?: string | undefined;
         authOptionKey?: string | undefined;
         lastActiveAt?: string | undefined;
         nextCredentialsRefreshAt?: string | undefined;
@@ -106,8 +109,8 @@ export declare class ConnectionAccessor {
             isDeactivated?: boolean | undefined;
             authType?: "proxy" | "integration-app-token" | "membrane-token" | "oauth2" | "oauth1" | "client-credentials" | undefined;
         } | undefined;
-    } | undefined>;
-    openReconnectUI({}?: OpenConfigurationOptions): Promise<void>;
+    } | null>;
+    openReconnectUI({}?: OpenConfigurationOptions): Promise<ConnectionApiResponse | null>;
     refreshCredentials(): Promise<void>;
     getPath(subpath?: string, query?: Record<string, any>): string;
 }
@@ -147,13 +150,16 @@ export declare class ConnectionProxy {
 export declare function createOrUpdateConnection(options?: {
     authOptionKey?: string;
     name?: string;
-    parameters?: any;
+    input?: any;
     connectorParameters?: any;
     integrationId?: string;
+    connectorId?: string;
+    connectorVersion?: string;
     connectionId?: string;
     connectorSpec?: ConnectorSpec;
     allowMultipleConnections?: boolean;
     token: string;
     apiUri: string;
     redirectUri?: string;
-}): Promise<Connection | undefined>;
+    onPopupClosed?: () => void;
+}): Promise<ConnectionApiResponse | null>;

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

@@ -5,17 +5,17 @@ import { IntegrationLevelFieldMappingAccessor, IntegrationLevelFieldMappingsList
 import { IntegrationLevelFlowAccessor, IntegrationLevelFlowsListAccessor } from './flows-accessors';
 import { MembraneApiClient } from '../api-client';
 import { OpenConfigurationOptions } from '../iframe';
-import { Connection } from '../workspace-elements/api/connections-api';
-import { CreateIntegrationRequest, UpdateIntegrationRequest, FindIntegrationsQuery, OpenNewConnectionOptions, Integration } from '../workspace-elements/api/integrations-api';
+import { ConnectionApiResponse } from '../workspace-elements/api/connections-api';
+import { CreateIntegrationRequest, UpdateIntegrationRequest, FindIntegrationsQuery, OpenNewConnectionOptions, IntegrationApiResponse } from '../workspace-elements/api/integrations-api';
 import { ConnectionSpec } from '../workspace-elements/base/connections';
 import { OperationListItem, OperationSpec } from '../workspace-elements/base/connectors';
 import { DataCollectionListItem, DataCollectionSpec } from '../workspace-elements/base/data-collections';
 interface OpenIntegrationUIIntegrationConfigurationOptions extends OpenConfigurationOptions {
 }
-export declare class IntegrationsAccessor extends ElementListAccessor<Integration, FindIntegrationsQuery, CreateIntegrationRequest> {
+export declare class IntegrationsAccessor extends ElementListAccessor<IntegrationApiResponse, FindIntegrationsQuery, CreateIntegrationRequest> {
     constructor(client: MembraneApiClient);
 }
-export declare class IntegrationAccessor extends ElementAccessor<Integration, UpdateIntegrationRequest> {
+export declare class IntegrationAccessor extends ElementAccessor<IntegrationApiResponse, UpdateIntegrationRequest> {
     private client;
     private integrationSelector;
     baseUri: string;
@@ -28,16 +28,18 @@ export declare class IntegrationAccessor extends ElementAccessor<Integration, Up
     dataSource(dataSourceSelector: string): IntegrationLevelDataSourceAccessor;
     get fieldMappings(): IntegrationLevelFieldMappingsListAccessor;
     fieldMapping(fieldMappingSelector: string): IntegrationLevelFieldMappingAccessor;
-    setup(): Promise<Integration>;
+    setup(): Promise<IntegrationApiResponse>;
     getConnectorSpec(): Promise<ConnectionSpec>;
     open({ onClose }?: OpenIntegrationUIIntegrationConfigurationOptions): Promise<void>;
-    openNewConnection({ allowMultipleConnections, name, connectorParameters, }?: OpenNewConnectionOptions): Promise<Connection>;
-    connect({ name, parameters, connectorParameters, authOptionKey, allowMultipleConnections, redirectUri, sameWindow, }?: {
+    openNewConnection({ allowMultipleConnections, name, connectorParameters, }?: OpenNewConnectionOptions): Promise<ConnectionApiResponse | null>;
+    connect({ name, input, parameters, connectorParameters, authOptionKey, allowMultipleConnections, redirectUri, sameWindow, onPopupClosed, }?: {
         name?: string;
+        input?: any;
         parameters?: any;
         connectorParameters?: any;
         authOptionKey?: string;
         allowMultipleConnections?: boolean;
+        onPopupClosed?: () => void;
     } & ({
         sameWindow: true;
         redirectUri: string;
@@ -48,7 +50,6 @@ export declare class IntegrationAccessor extends ElementAccessor<Integration, Up
         id: string;
         name: string;
         userId: string;
-        integrationId: string;
         createdAt: string;
         updatedAt: string;
         isTest?: boolean | undefined;
@@ -56,6 +57,9 @@ export declare class IntegrationAccessor extends ElementAccessor<Integration, Up
         isDefunct?: boolean | undefined;
         state?: import("../workspace-elements").WorkspaceElementState | undefined;
         error?: import("../errors").ErrorDataSchema | undefined;
+        integrationId?: string | undefined;
+        connectorId?: string | undefined;
+        connectorVersion?: string | undefined;
         authOptionKey?: string | undefined;
         lastActiveAt?: string | undefined;
         nextCredentialsRefreshAt?: string | undefined;
@@ -110,11 +114,11 @@ export declare class IntegrationAccessor extends ElementAccessor<Integration, Up
             isDeactivated?: boolean | undefined;
             authType?: "proxy" | "integration-app-token" | "membrane-token" | "oauth2" | "oauth1" | "client-credentials" | undefined;
         } | undefined;
-    } | undefined>;
-    createConnection({ parameters, name }: {
+    } | null>;
+    createConnection({ parameters, name, }: {
         parameters?: any;
         name?: string;
-    }): Promise<Connection | undefined>;
+    }): Promise<ConnectionApiResponse | null>;
     getOperations(): Promise<OperationListItem[]>;
     getOperation(key: string): Promise<OperationSpec>;
     getDataCollections(): Promise<DataCollectionListItem[]>;

package/dist/dts/agent/session.d.ts

@@ -13,8 +13,13 @@ export declare enum AgentSessionState {
     BUSY = "busy",
     IDLE = "idle"
 }
+export declare enum AgentName {
+    MEMBRANE = "membrane",
+    SELF_INTEGRATING = "self-integrating"
+}
 export declare const AgentSession: z.ZodObject<{
     id: z.ZodString;
+    workspaceId: z.ZodString;
     userId: z.ZodOptional<z.ZodString>;
     workspaceElementType: z.ZodEnum<typeof WorkspaceElementType>;
     workspaceElementId: z.ZodString;
@@ -29,6 +34,8 @@ export declare const AgentSession: z.ZodObject<{
     state: z.ZodDefault<z.ZodEnum<typeof AgentSessionState>>;
     usage: z.ZodOptional<z.ZodNumber>;
     hasWorker: z.ZodBoolean;
+    isExternal: z.ZodOptional<z.ZodBoolean>;
+    agentName: z.ZodOptional<z.ZodEnum<typeof AgentName>>;
     createdAt: z.ZodISODateTime;
     updatedAt: z.ZodISODateTime;
 }, z.core.$strip>;
@@ -39,6 +46,7 @@ export declare const CreateAgentSession: z.ZodObject<{
     prompt: z.ZodString;
     testCustomerId: z.ZodOptional<z.ZodString>;
     isExternal: z.ZodOptional<z.ZodBoolean>;
+    modelId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type CreateAgentSession = z.infer<typeof CreateAgentSession>;
 export declare const AgentSessionInputSchema: z.ZodObject<{
@@ -52,6 +60,8 @@ export declare const PatchAgentSessionSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     summary: z.ZodOptional<z.ZodString>;
     cost: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodType<ErrorDataSchema, unknown, z.core.$ZodTypeInternals<ErrorDataSchema, unknown>>>;
+    opencodeSessionUuid: z.ZodOptional<z.ZodString>;
     status: z.ZodOptional<z.ZodEnum<typeof AgentSessionStatus>>;
 }, z.core.$strip>;
 export type PatchAgentSession = z.infer<typeof PatchAgentSessionSchema>;

package/dist/dts/alerts/index.d.ts

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

package/dist/dts/alerts/types.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export declare enum AlertStatus {
     ONGOING = "ongoing",
     RESOLVED = "resolved"
@@ -7,22 +8,114 @@ export declare enum AlertSeverity {
     WARNING = "warning"
 }
 export declare enum AlertType {
+    fileUploadsMbPerHour = "fileUploadsMbPerHour",
+    apiRequestsPerSecond = "apiRequestsPerSecond",
+    apiRequestsPerHour = "apiRequestsPerHour",
+    webhookRequestsPerSecond = "webhookRequestsPerSecond",
+    webhookRequestsPerHour = "webhookRequestsPerHour",
+    workspaceElementCreationsPerSecond = "workspaceElementCreationsPerSecond",
+    workspaceElementCreationsPerHour = "workspaceElementCreationsPerHour",
     externalEventsPerCustomerPerDay = "externalEventsPerCustomerPerDay",
     totalUsagePerDay = "totalUsagePerDay",
     totalUsagePer30Days = "totalUsagePer30Days",
-    membraneAgentUsagePer30Days = "membraneAgentUsagePer30Days",
     testAlert = "testAlert"
 }
-export interface Alert {
-    id: string;
-    description: string;
-    status: AlertStatus;
-    type: AlertType;
-    workspaceId: string;
-    createdAt: Date;
-    updatedAt: Date;
-    lastSeenAt: Date;
-    resolvedAt?: Date;
-    customerId?: string;
-    severity: AlertSeverity;
+export declare enum AlertCategory {
+    RATE_LIMIT = "rateLimit",
+    USAGE = "usage",
+    TEST = "test"
 }
+export declare const ALERT_TYPE_CATEGORIES: {
+    readonly fileUploadsMbPerHour: AlertCategory.RATE_LIMIT;
+    readonly apiRequestsPerSecond: AlertCategory.RATE_LIMIT;
+    readonly apiRequestsPerHour: AlertCategory.RATE_LIMIT;
+    readonly webhookRequestsPerSecond: AlertCategory.RATE_LIMIT;
+    readonly webhookRequestsPerHour: AlertCategory.RATE_LIMIT;
+    readonly workspaceElementCreationsPerSecond: AlertCategory.RATE_LIMIT;
+    readonly workspaceElementCreationsPerHour: AlertCategory.RATE_LIMIT;
+    readonly externalEventsPerCustomerPerDay: AlertCategory.RATE_LIMIT;
+    readonly totalUsagePerDay: AlertCategory.USAGE;
+    readonly totalUsagePer30Days: AlertCategory.USAGE;
+    readonly testAlert: AlertCategory.TEST;
+};
+type AlertsByCategory<C extends AlertCategory> = {
+    [K in keyof typeof ALERT_TYPE_CATEGORIES]: (typeof ALERT_TYPE_CATEGORIES)[K] extends C ? K : never;
+}[keyof typeof ALERT_TYPE_CATEGORIES];
+export type RateLimitAlerts = AlertsByCategory<AlertCategory.RATE_LIMIT>;
+export type UsageAlerts = AlertsByCategory<AlertCategory.USAGE>;
+export type TestAlerts = AlertsByCategory<AlertCategory.TEST>;
+export declare const AlertSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        ongoing: AlertStatus.ONGOING;
+        resolved: AlertStatus.RESOLVED;
+    }>;
+    type: z.ZodEnum<{
+        fileUploadsMbPerHour: AlertType.fileUploadsMbPerHour;
+        apiRequestsPerSecond: AlertType.apiRequestsPerSecond;
+        apiRequestsPerHour: AlertType.apiRequestsPerHour;
+        webhookRequestsPerSecond: AlertType.webhookRequestsPerSecond;
+        webhookRequestsPerHour: AlertType.webhookRequestsPerHour;
+        workspaceElementCreationsPerSecond: AlertType.workspaceElementCreationsPerSecond;
+        workspaceElementCreationsPerHour: AlertType.workspaceElementCreationsPerHour;
+        externalEventsPerCustomerPerDay: AlertType.externalEventsPerCustomerPerDay;
+        totalUsagePerDay: AlertType.totalUsagePerDay;
+        totalUsagePer30Days: AlertType.totalUsagePer30Days;
+        testAlert: AlertType.testAlert;
+    }>;
+    workspaceId: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    lastSeenAt: z.ZodDate;
+    resolvedAt: z.ZodOptional<z.ZodDate>;
+    customerId: z.ZodOptional<z.ZodString>;
+    severity: z.ZodEnum<{
+        critical: AlertSeverity.CRITICAL;
+        warning: AlertSeverity.WARNING;
+    }>;
+}, z.core.$strip>;
+export type Alert = z.infer<typeof AlertSchema>;
+export declare const ALERT_DELIVERY_METHODS: readonly ["internal", "webhook", "email"];
+export type AlertDeliveryMethod = (typeof ALERT_DELIVERY_METHODS)[number];
+export declare const AlertTypeDeliverySettingsSchema: z.ZodObject<{
+    internal: z.ZodLiteral<true>;
+    webhook: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>;
+    email: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AlertTypeDeliverySettings = z.infer<typeof AlertTypeDeliverySettingsSchema> & {
+    [key: string]: true | {
+        enabled: boolean;
+    };
+};
+export declare const DEFAULT_ALERT_TYPE_DELIVERY_SETTINGS: Required<AlertTypeDeliverySettings>;
+export declare const AlertDeliverySettingsSchema: z.ZodObject<{
+    alertTypes: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        fileUploadsMbPerHour: AlertType.fileUploadsMbPerHour;
+        apiRequestsPerSecond: AlertType.apiRequestsPerSecond;
+        apiRequestsPerHour: AlertType.apiRequestsPerHour;
+        webhookRequestsPerSecond: AlertType.webhookRequestsPerSecond;
+        webhookRequestsPerHour: AlertType.webhookRequestsPerHour;
+        workspaceElementCreationsPerSecond: AlertType.workspaceElementCreationsPerSecond;
+        workspaceElementCreationsPerHour: AlertType.workspaceElementCreationsPerHour;
+        externalEventsPerCustomerPerDay: AlertType.externalEventsPerCustomerPerDay;
+        totalUsagePerDay: AlertType.totalUsagePerDay;
+        totalUsagePer30Days: AlertType.totalUsagePer30Days;
+        testAlert: AlertType.testAlert;
+    }>, z.ZodOptional<z.ZodObject<{
+        internal: z.ZodLiteral<true>;
+        webhook: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        email: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type AlertDeliverySettings = z.infer<typeof AlertDeliverySettingsSchema>;
+export declare const DEFAULT_ALERT_DELIVERY_SETTINGS: AlertDeliverySettings;
+export {};

package/dist/dts/alerts/utils.d.ts

@@ -0,0 +1,8 @@
+import { AlertCategory, AlertType } from './types';
+import type { AlertDeliveryMethod, AlertTypeDeliverySettings } from './types';
+export declare function isValidAlertType(value: string): value is AlertType;
+export declare function getAlertTypeDisplayName(alertType: AlertType): string;
+export declare function getAlertDeliveryMethodLabel(method: AlertDeliveryMethod): string;
+export declare function isDeliveryMethodEnabled(settings: AlertTypeDeliverySettings, method: AlertDeliveryMethod): boolean;
+export declare function getAlertCategoryDisplayName(category: AlertCategory): string;
+export declare function getAlertTypesByCategory(category: AlertCategory): readonly AlertType[];

package/dist/dts/config/index.d.ts

@@ -6,6 +6,7 @@ export declare const membraneConfigSchema: z.ZodObject<{
     apiUri: z.ZodOptional<z.ZodString>;
     consoleUri: z.ZodOptional<z.ZodString>;
     testCustomerId: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type MembraneConfig = z.infer<typeof membraneConfigSchema>;
 export type PartialMembraneConfig = Partial<MembraneConfig>;

package/dist/dts/dto/index.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare function addUndefinedWriteableProperties<T extends z.ZodTypeAny>(value: Record<string, unknown>, schema: T): z.infer<T>;
+export declare function lenientParseWithSchema<T extends z.ZodTypeAny>(data: unknown, schema: T): z.infer<T>;

package/dist/dts/functions/base.d.ts

@@ -17,12 +17,12 @@ export declare const BaseFunctionDefinition: z.ZodObject<{
 }, z.core.$strip>;
 export type BaseFunctionDefinition = z.infer<typeof BaseFunctionDefinition>;
 export declare const GenericFunctionDefinition: z.ZodObject<{
-    type: z.ZodEnum<{
+    type: z.ZodOptional<z.ZodEnum<{
         mapping: "mapping";
         "operation-mapping": "operation-mapping";
         "rest-api-mapping": "rest-api-mapping";
         "graphql-api-mapping": "graphql-api-mapping";
         javascript: "javascript";
-    }>;
+    }>>;
 }, z.core.$loose>;
 export type GenericFunctionDefinition = z.infer<typeof GenericFunctionDefinition>;

package/dist/dts/index.browser.d.ts

@@ -31,6 +31,7 @@ export * from './scenario-templates';
 export * from './agent';
 export * from './validation';
 export * from './functions';
+export * from './dto';
 export { MembraneClient as IntegrationAppClient } from './client';
 export { MembraneClient as MembraneClient } from './client';
 export { axios as MembraneAxiosInstance } from './api-client';

package/dist/dts/logging/index.d.ts

@@ -5,4 +5,13 @@ export type WithExecutionLogs<T extends Record<string, any>> = T & {
 };
 export declare function isStream(obj: any): boolean;
 export declare function streamToString(stream: Readable): Promise<string>;
+interface BlobLike {
+    readonly size: number;
+    readonly type: string;
+    slice(start?: number, end?: number, contentType?: string): BlobLike;
+    stream(): ReadableStream<Uint8Array> | NodeJS.ReadableStream;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+export declare function isBlob(value: unknown): value is BlobLike;
 export declare function truncateData(data: any, depth?: number): any;

package/dist/dts/orgs/types.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export type OrgFeatureFlags = Record<string, boolean>;
 export declare enum OrgLimitsType {
     NUMBER_OF_WORKSPACES = "numberOfWorkspaces",
     TODAY_USAGE = "todayUsage",
@@ -16,6 +17,7 @@ export interface Org {
     key: string;
     secret?: string;
     name: string;
+    plan?: OrgPlan;
     createdAt: Date;
     updatedAt: Date;
     trialEndDate?: string;
@@ -31,6 +33,19 @@ export interface Org {
     autoChargeThreshold?: number;
     autoChargePurchaseAmount?: number;
     autoChargeMonthlyLimit?: number;
+    freeInfraCredits?: number;
+    paidInfraCredits?: number;
+    freeInfraMonthlyCredits?: number | null;
+    infraAutoChargeEnabled?: boolean;
+    infraAutoChargeThreshold?: number;
+    infraAutoChargePurchaseAmount?: number;
+    infraAutoChargeMonthlyLimit?: number;
+    effectiveFeatureFlags?: OrgFeatureFlags;
+}
+export declare enum OrgPlan {
+    Core = "core",
+    Pro = "pro",
+    Ultimate = "ultimate"
 }
 export declare enum OrgUserRole {
     Admin = "admin",
@@ -85,10 +100,12 @@ export declare const MembraneAgentKey: z.ZodOptional<z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     expiresAt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
+export declare const OrgFeatureFlagsSchema: z.ZodRecord<z.ZodString, z.ZodBoolean>;
 export declare const OrgSchema: z.ZodObject<{
     id: z.ZodString;
     key: z.ZodString;
     name: z.ZodString;
+    plan: z.ZodOptional<z.ZodEnum<typeof OrgPlan>>;
     createdAt: z.ZodCoercedDate<unknown>;
     updatedAt: z.ZodCoercedDate<unknown>;
     trialEndDate: z.ZodOptional<z.ZodString>;
@@ -113,6 +130,14 @@ export declare const OrgSchema: z.ZodObject<{
     autoChargeThreshold: z.ZodOptional<z.ZodNumber>;
     autoChargePurchaseAmount: z.ZodOptional<z.ZodNumber>;
     autoChargeMonthlyLimit: z.ZodOptional<z.ZodNumber>;
+    freeInfraCredits: z.ZodOptional<z.ZodNumber>;
+    paidInfraCredits: z.ZodOptional<z.ZodNumber>;
+    freeInfraMonthlyCredits: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    infraAutoChargeEnabled: z.ZodOptional<z.ZodBoolean>;
+    infraAutoChargeThreshold: z.ZodOptional<z.ZodNumber>;
+    infraAutoChargePurchaseAmount: z.ZodOptional<z.ZodNumber>;
+    infraAutoChargeMonthlyLimit: z.ZodOptional<z.ZodNumber>;
+    effectiveFeatureFlags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
 }, z.core.$strip>;
 export declare const AccountResponse: z.ZodObject<{
     user: z.ZodOptional<z.ZodObject<{
@@ -125,8 +150,12 @@ export declare const AccountResponse: z.ZodObject<{
         isAdmin: z.ZodOptional<z.ZodBoolean>;
         trialRequested: z.ZodBoolean;
         pat: z.ZodOptional<z.ZodString>;
-        introVideoStatus: z.ZodOptional<z.ZodString>;
         isEligible: z.ZodOptional<z.ZodBoolean>;
+        ineligibilityReason: z.ZodOptional<z.ZodEnum<{
+            disposable: "disposable";
+            blockedDomain: "blockedDomain";
+            notCompanyEmail: "notCompanyEmail";
+        }>>;
         emailVerified: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     workspace: z.ZodOptional<z.ZodObject<{
@@ -335,6 +364,11 @@ export declare const AccountResponse: z.ZodObject<{
                 defaultValue: z.ZodOptional<z.ZodNumber>;
                 unit: z.ZodEnum<typeof import("../workspaces").LimitUnits>;
             }, z.core.$strip>>;
+            QueuedTasksQueueSize: z.ZodOptional<z.ZodObject<{
+                value: z.ZodOptional<z.ZodNumber>;
+                defaultValue: z.ZodOptional<z.ZodNumber>;
+                unit: z.ZodEnum<typeof import("../workspaces").LimitUnits>;
+            }, z.core.$strip>>;
             parallelApiRequestsPerCustomer: z.ZodOptional<z.ZodObject<{
                 value: z.ZodOptional<z.ZodNumber>;
                 defaultValue: z.ZodOptional<z.ZodNumber>;
@@ -391,6 +425,30 @@ export declare const AccountResponse: z.ZodObject<{
             enableWebhookLogs: z.ZodOptional<z.ZodBoolean>;
             enableActionRunLogs: z.ZodOptional<z.ZodBoolean>;
             disableSecretKeyAuth: z.ZodOptional<z.ZodBoolean>;
+            useMembraneUniverse: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        alertDeliverySettings: z.ZodOptional<z.ZodObject<{
+            alertTypes: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+                fileUploadsMbPerHour: import("../alerts").AlertType.fileUploadsMbPerHour;
+                apiRequestsPerSecond: import("../alerts").AlertType.apiRequestsPerSecond;
+                apiRequestsPerHour: import("../alerts").AlertType.apiRequestsPerHour;
+                webhookRequestsPerSecond: import("../alerts").AlertType.webhookRequestsPerSecond;
+                webhookRequestsPerHour: import("../alerts").AlertType.webhookRequestsPerHour;
+                workspaceElementCreationsPerSecond: import("../alerts").AlertType.workspaceElementCreationsPerSecond;
+                workspaceElementCreationsPerHour: import("../alerts").AlertType.workspaceElementCreationsPerHour;
+                externalEventsPerCustomerPerDay: import("../alerts").AlertType.externalEventsPerCustomerPerDay;
+                totalUsagePerDay: import("../alerts").AlertType.totalUsagePerDay;
+                totalUsagePer30Days: import("../alerts").AlertType.totalUsagePer30Days;
+                testAlert: import("../alerts").AlertType.testAlert;
+            }>, z.ZodOptional<z.ZodObject<{
+                internal: z.ZodLiteral<true>;
+                webhook: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                }, z.core.$strip>>;
+                email: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>>;
         }, z.core.$strip>>;
         type: z.ZodOptional<z.ZodEnum<typeof import("../workspaces").WorkspaceType>>;
         jwksUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -404,6 +462,7 @@ export declare const AccountResponse: z.ZodObject<{
         id: z.ZodString;
         key: z.ZodString;
         name: z.ZodString;
+        plan: z.ZodOptional<z.ZodEnum<typeof OrgPlan>>;
         createdAt: z.ZodCoercedDate<unknown>;
         updatedAt: z.ZodCoercedDate<unknown>;
         trialEndDate: z.ZodOptional<z.ZodString>;
@@ -428,6 +487,14 @@ export declare const AccountResponse: z.ZodObject<{
         autoChargeThreshold: z.ZodOptional<z.ZodNumber>;
         autoChargePurchaseAmount: z.ZodOptional<z.ZodNumber>;
         autoChargeMonthlyLimit: z.ZodOptional<z.ZodNumber>;
+        freeInfraCredits: z.ZodOptional<z.ZodNumber>;
+        paidInfraCredits: z.ZodOptional<z.ZodNumber>;
+        freeInfraMonthlyCredits: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        infraAutoChargeEnabled: z.ZodOptional<z.ZodBoolean>;
+        infraAutoChargeThreshold: z.ZodOptional<z.ZodNumber>;
+        infraAutoChargePurchaseAmount: z.ZodOptional<z.ZodNumber>;
+        infraAutoChargeMonthlyLimit: z.ZodOptional<z.ZodNumber>;
+        effectiveFeatureFlags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
     }, z.core.$strip>>>;
     permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     message: z.ZodOptional<z.ZodString>;

package/dist/dts/platform-users.d.ts

@@ -1,11 +1,21 @@
 import { z } from 'zod';
+declare const IneligibilityReasonSchema: z.ZodEnum<{
+    disposable: "disposable";
+    blockedDomain: "blockedDomain";
+    notCompanyEmail: "notCompanyEmail";
+}>;
+export type IneligibilityReason = z.infer<typeof IneligibilityReasonSchema>;
 export declare const PlatformUserSchema: z.ZodObject<{
     id: z.ZodString;
     email: z.ZodString;
     name: z.ZodString;
     trialRequested: z.ZodBoolean;
-    introVideoStatus: z.ZodOptional<z.ZodString>;
     isEligible: z.ZodOptional<z.ZodBoolean>;
+    ineligibilityReason: z.ZodOptional<z.ZodEnum<{
+        disposable: "disposable";
+        blockedDomain: "blockedDomain";
+        notCompanyEmail: "notCompanyEmail";
+    }>>;
     emailVerified: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const FullPlatformUser: z.ZodObject<{
@@ -18,7 +28,12 @@ export declare const FullPlatformUser: z.ZodObject<{
     isAdmin: z.ZodOptional<z.ZodBoolean>;
     trialRequested: z.ZodBoolean;
     pat: z.ZodOptional<z.ZodString>;
-    introVideoStatus: z.ZodOptional<z.ZodString>;
     isEligible: z.ZodOptional<z.ZodBoolean>;
+    ineligibilityReason: z.ZodOptional<z.ZodEnum<{
+        disposable: "disposable";
+        blockedDomain: "blockedDomain";
+        notCompanyEmail: "notCompanyEmail";
+    }>>;
     emailVerified: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
+export {};

package/dist/dts/usage/types.d.ts

@@ -12,6 +12,7 @@ export declare enum UsageType {
     EXTERNAL_EVENTS_PULL_DURATION = "external-events-pull-duration",
     EXTERNAL_EVENT_PULL_NUMBER = "external-event-pull-number",
     EXTERNAL_EVENT_PULL_LOG_SIZE = "external-event-pull-log-size",
+    EXTERNAL_EVENT_WEBHOOK_REFRESH_DURATION = "external-event-webhook-refresh-duration",
     APP_EVENTS_NUMBER = "app-events-number",
     APP_EVENTS_SIZE = "app-events-size",
     FILES_UPLOAD_NUMBER = "files-upload-number",

package/dist/dts/webhooks/types.d.ts

@@ -5,9 +5,11 @@ export declare enum WebhookTypeEnum {
     TASK_CREATED = "task-created",
     TASK_UPDATED = "task-updated",
     TASK_ACTIVITY_CREATED = "task-activity-created",
-    CONNECTOR_VERSION_PUBLISHED = "connector-version-published"
+    CONNECTOR_VERSION_PUBLISHED = "connector-version-published",
+    AGENT_SESSION_FINISHED = "agent-session-finished",
+    SEND_ALERT_EMAIL = "send-alert-email"
 }
-export type WebhookType = WebhookTypeEnum.USER_INVITED_TO_ORG | WebhookTypeEnum.ORG_ACCESS_REQUESTED | WebhookTypeEnum.ORG_CREATED | WebhookTypeEnum.TASK_CREATED | WebhookTypeEnum.TASK_UPDATED | WebhookTypeEnum.TASK_ACTIVITY_CREATED | WebhookTypeEnum.CONNECTOR_VERSION_PUBLISHED;
+export type WebhookType = WebhookTypeEnum.USER_INVITED_TO_ORG | WebhookTypeEnum.ORG_ACCESS_REQUESTED | WebhookTypeEnum.ORG_CREATED | WebhookTypeEnum.TASK_CREATED | WebhookTypeEnum.TASK_UPDATED | WebhookTypeEnum.TASK_ACTIVITY_CREATED | WebhookTypeEnum.CONNECTOR_VERSION_PUBLISHED | WebhookTypeEnum.AGENT_SESSION_FINISHED | WebhookTypeEnum.SEND_ALERT_EMAIL;
 export interface Webhook {
     type: WebhookType;
     url: string;

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

@@ -124,7 +124,9 @@ export declare const ActionRunLogRecordApiResponse: z.ZodObject<{
         isDefunct: z.ZodOptional<z.ZodBoolean>;
         state: z.ZodOptional<z.ZodEnum<typeof import("..").WorkspaceElementState>>;
         error: z.ZodOptional<z.ZodType<import("../../errors").ErrorDataSchema, unknown, z.core.$ZodTypeInternals<import("../../errors").ErrorDataSchema, unknown>>>;
-        integrationId: z.ZodString;
+        integrationId: z.ZodOptional<z.ZodString>;
+        connectorId: z.ZodOptional<z.ZodString>;
+        connectorVersion: z.ZodOptional<z.ZodString>;
         authOptionKey: z.ZodOptional<z.ZodString>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
@@ -288,7 +290,9 @@ export declare const FindActionRunLogsResponse: z.ZodObject<{
             isDefunct: z.ZodOptional<z.ZodBoolean>;
             state: z.ZodOptional<z.ZodEnum<typeof import("..").WorkspaceElementState>>;
             error: z.ZodOptional<z.ZodType<import("../../errors").ErrorDataSchema, unknown, z.core.$ZodTypeInternals<import("../../errors").ErrorDataSchema, unknown>>>;
-            integrationId: z.ZodString;
+            integrationId: z.ZodOptional<z.ZodString>;
+            connectorId: z.ZodOptional<z.ZodString>;
+            connectorVersion: z.ZodOptional<z.ZodString>;
             authOptionKey: z.ZodOptional<z.ZodString>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;