@membranehq/sdk 0.2.1 → 0.4.0

package/dist/dts/data-filter/index.d.ts

@@ -1,5 +1,5 @@
 import { DataFilterOperator } from './operators';
-import { DataLocator } from '../data-builder/locators';
+import { DataLocator } from '../locators';
 export declare function backwardCompatibleFilterMatch(filter: any, variables: any): any;
 export declare function doesMatchFilter(data: any, filter: DataFilter): boolean;
 export declare class DataFilterCondition {

package/dist/dts/data-schema/index.d.ts

@@ -1,5 +1,4 @@
 export * from './create';
-export * from './data-field';
 export * from './merge';
+export * from './schemas';
 export * from './types';
-export * from './utils';

package/dist/dts/data-schema/schemas.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+declare const DataSchemaSchema: any;
+export { DataSchemaSchema };
+export type DataSchemaType = z.infer<typeof DataSchemaSchema>;

package/dist/dts/data-schema/types.d.ts

@@ -1,4 +1,4 @@
-import { DataRecord } from '../data-collections';
+import { DataRecord } from '../workspace-elements/base/data-collections';
 export interface DataSchema {
     title?: string;
     description?: string;

package/dist/dts/{data-schema/utils.d.ts → data-schema-utils/index.d.ts}

@@ -1,6 +1,4 @@
-import { DataLocationPointer } from '../connectors';
-import { DataSchema } from './types';
-export declare function buildDataSchema(value: any, variablesSchema?: any): any;
+import { DataSchema } from '../data-schema/types';
 export declare function updateImpliedSchema({ schema, value, variablesSchema, }: {
     schema: DataSchema | undefined;
     value: any;
@@ -13,8 +11,9 @@ export declare function updateImpliedSchema({ schema, value, variablesSchema, }:
 }): DataSchema;
 export declare function schemaHasProperties(schema?: DataSchema): boolean;
 export declare function nonEmptyObjectProperties(properties: Record<string, DataSchema | undefined | null>): Record<string, DataSchema>;
-export declare function getSchemaFromValue(value: any, variablesSchema: any, ignoreFormulas?: boolean): any;
 export declare function schemaTypeFromValue(value: any): "object" | "boolean" | "number" | "string" | "array" | undefined;
+export declare function buildDataSchema(value: any, variablesSchema?: any): any;
+export declare function getSchemaFromValue(value: any, variablesSchema: any, ignoreFormulas?: boolean): any;
 export interface ValueToSchemaOptions {
     addDefaults?: boolean;
     skipUnknownFields?: boolean;
@@ -42,6 +41,4 @@ export declare function populateSchemaTitles(schema: DataSchema): DataSchema;
 export declare function generateExampleFromSchema(schema: DataSchema | undefined): any;
 export declare function isSchemaEmpty(schema: DataSchema): boolean;
 export declare function compressDataSchema(schema: DataSchema): DataSchema;
-export declare function getReferenceCollectionPointerForSchema(schema: DataSchema | undefined): DataLocationPointer | undefined;
-export declare function getReferenceCollectionPathForSchema(schema: DataSchema | undefined): string | undefined;
 export declare function walkSchema(schema: DataSchema | undefined, callback: (schema: DataSchema, locator: string) => DataSchema | undefined, locator?: string): DataSchema | undefined;

package/dist/dts/error-tools/index.d.ts

@@ -0,0 +1,3 @@
+import { ErrorData } from '../errors';
+export declare function getErrorFromData(data: any): any;
+export declare function extractIntegrationAppErrorData(error: any): ErrorData;

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

@@ -1,6 +1,4 @@
-import { WorkspaceElementReference } from '../workspace-elements';
-import { ErrorDoc } from './error-doc-enum';
-export * from './error-doc-enum';
+import { z } from 'zod';
 export declare enum ErrorType {
     BAD_REQUEST = "bad_request",
     CONNECTION = "connection",
@@ -30,17 +28,10 @@ export declare enum ConnectionErrorKey {
 export declare enum ConcurrencyErrorKey {
     LOCK_TIMEOUT = "lock_timeout"
 }
-interface ErrorDataFields {
-    type?: ErrorType;
-    key?: string;
-    message: string;
-    data?: any;
-    doc?: ErrorDoc;
-    stack?: any;
-    causedByError?: ErrorData;
-    logs?: any[];
-}
-type ErrorConstructorArg = string | ErrorDataFields | Error;
+export declare const ErrorDataSchema: any;
+interface ErrorDataFields extends z.infer<typeof ErrorDataSchema> {
+}
+export type ErrorConstructorArg = string | ErrorDataFields | Error;
 export declare function isIntegrationAppError(error: any): any;
 export declare class ErrorData implements ErrorDataFields {
     constructor(arg: ErrorConstructorArg);
@@ -64,9 +55,6 @@ export declare class ConcurrencyError extends IntegrationAppError {
 export declare class ConfigurationError extends IntegrationAppError {
     constructor(arg: ErrorConstructorArg);
 }
-export declare class DependencyError extends IntegrationAppError {
-    constructor(arg: ErrorConstructorArg, workspaceElementReference?: WorkspaceElementReference);
-}
 export declare class FlowInstanceSetupError extends IntegrationAppError {
     constructor(arg: ErrorConstructorArg);
 }
@@ -100,6 +88,4 @@ export declare class AccessDeniedError extends BadRequestError {
 export declare class CustomCodeError extends IntegrationAppError {
     constructor(arg: ErrorConstructorArg);
 }
-export declare function getErrorFromData(data: any): any;
-export declare function extractIntegrationAppErrorData(error: any): ErrorData;
-export declare function buildUserFriendlyErrorMessage({ message, doc }: ErrorData): string;
+export {};

package/dist/dts/{data-builder/formulas → formulas}/base.d.ts

@@ -1,6 +1,6 @@
 import { DataBuilderFormulaType } from './types';
-import { DataCollectionSpec } from '../../connectors';
-import { DataSchema } from '../../data-schema';
+import { DataSchema } from '../data-schema/types';
+import { DataCollectionSpec } from '../workspace-elements/base/data-collections';
 export interface LookupValue {
     query: Record<string, any>;
     createIfNotFound?: boolean;

package/dist/dts/{data-builder/formulas → formulas}/dataSchemaRef.d.ts

@@ -13,9 +13,9 @@ export declare class DataSchemaRef extends DataBuilderFormulaBase<DataSchemaRefA
     value: any;
     constructor(value: any);
     getValue(): undefined;
-    resolveValue(params: ResolveFormulaParams): Promise<import("../..").DataSchema | undefined>;
-    resolveDataCollection(args: DataSchemaRegArgsDataCollection, params: ResolveFormulaParams): Promise<import("../..").DataSchema | undefined>;
-    resolveInternalDataSchema(args: DataSchemaRegArgsInternalDataSchema, params: ResolveFormulaParams): Promise<import("../..").DataSchema | undefined>;
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    resolveDataCollection(args: DataSchemaRegArgsDataCollection, params: ResolveFormulaParams): Promise<any>;
+    resolveInternalDataSchema(args: DataSchemaRegArgsInternalDataSchema, params: ResolveFormulaParams): Promise<import("..").DataSchema | undefined>;
     getSchema(): {
         type: string;
     };

package/dist/dts/{data-builder/formulas → formulas}/eval.d.ts

@@ -1,5 +1,5 @@
-import { DataSchema } from '../../data-schema';
 import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+import type { DataSchema } from '../data-schema/types';
 export interface EvalOperator {
     key: string;
     name: string;

package/dist/dts/{data-builder/formulas → formulas}/findAppRecordId.d.ts

@@ -1,5 +1,5 @@
-import { DataLinkTableConfig } from '../../data-links';
 import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+import { DataLinkTableConfig } from '../workspace-elements';
 export interface FindAppRecordIdArgs {
     dataLinkTable: DataLinkTableConfig;
     recordId: string;

package/dist/dts/{data-builder/formulas → formulas}/findExternalRecordId.d.ts

@@ -1,5 +1,5 @@
-import { DataLinkTableConfig } from '../../data-links';
 import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+import { DataLinkTableConfig } from '../workspace-elements';
 export interface FindExternalRecordIdArgs {
     dataLinkTable: DataLinkTableConfig;
     recordId: string;

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

@@ -0,0 +1,91 @@
+import { And } from './and';
+import { DataBuilderFormulaBase } from './base';
+import { DataBuilderFormulaCase } from './case';
+import { DataBuilderFormulaConcat } from './concat';
+import { DataBuilderFormulaCopy } from './copy';
+import { DataSchemaRef } from './dataSchemaRef';
+import { DomainFromEmail } from './domainFromEmail';
+import { Eval } from './eval';
+import { DataBuilderFormulaExtractDate } from './extractDate';
+import { DataBuilderFormulaExtractTime } from './extractTime';
+import { DataBuilderFormulaFindAppRecordId } from './findAppRecordId';
+import { DataBuilderFormulaFindExternalRecordId } from './findExternalRecordId';
+import { DataBuilderFormulaFirstName } from './first-name';
+import { FirstNotEmpty } from './firstNotEmpty';
+import { FormulaFormula } from './formula';
+import { DataBuilderFormulaIterate } from './iterate';
+import { JsonataFormula } from './jsonata';
+import { DataBuilderFormulaLastName } from './last-name';
+import { DataBuilderFormulaLookup } from './lookup';
+import { DataBuilderFormulaMap } from './map';
+import { MergeObjects } from './mergeObjects';
+import { Or } from './or';
+import { DataBuilderFormulaPlain } from './plain';
+import { DataBuilderFormulaRecord } from './record';
+import { DataBuilderFormulaTpl } from './tpl';
+import { DataBuilderFormulaVar } from './var';
+export { CaseFormulaValue, CaseFormulaValueItem } from './case';
+export { EvalOperator } from './eval';
+export { LookupValue, ResolveFormulaParams } from './base';
+export { MappingItem, MapFormulaValue } from './map';
+export { DataBuilderFormulaType } from './types';
+export declare const Formula: {
+    Var: typeof DataBuilderFormulaVar;
+    Record: typeof DataBuilderFormulaRecord;
+    Tpl: typeof DataBuilderFormulaTpl;
+    Lookup: typeof DataBuilderFormulaLookup;
+    Plain: typeof DataBuilderFormulaPlain;
+    Map: typeof DataBuilderFormulaMap;
+    And: typeof And;
+    Or: typeof Or;
+    MergeObjects: typeof MergeObjects;
+    FirstNotEmpty: typeof FirstNotEmpty;
+    DomainFromEmail: typeof DomainFromEmail;
+    Formula: typeof FormulaFormula;
+    Base: typeof DataBuilderFormulaBase;
+    Case: typeof DataBuilderFormulaCase;
+    Concat: typeof DataBuilderFormulaConcat;
+    Copy: typeof DataBuilderFormulaCopy;
+    Eval: typeof Eval;
+    ExtractDate: typeof DataBuilderFormulaExtractDate;
+    ExtractTime: typeof DataBuilderFormulaExtractTime;
+    FindAppRecordId: typeof DataBuilderFormulaFindAppRecordId;
+    FindExternalRecordId: typeof DataBuilderFormulaFindExternalRecordId;
+    FirstName: typeof DataBuilderFormulaFirstName;
+    LastName: typeof DataBuilderFormulaLastName;
+    Iterate: typeof DataBuilderFormulaIterate;
+    Jsonata: typeof JsonataFormula;
+    DataSchemaRef: typeof DataSchemaRef;
+};
+export type Formula = {
+    Var: DataBuilderFormulaVar;
+    Record: DataBuilderFormulaRecord;
+    Tpl: DataBuilderFormulaTpl;
+    Lookup: DataBuilderFormulaLookup;
+    Plain: DataBuilderFormulaPlain;
+    Map: DataBuilderFormulaMap;
+    And: And;
+    Or: Or;
+    MergeObjects: MergeObjects;
+    FirstNotEmpty: FirstNotEmpty;
+    DomainFromEmail: DomainFromEmail;
+    Formula: FormulaFormula;
+    Base: DataBuilderFormulaBase;
+    Case: DataBuilderFormulaCase;
+    Concat: DataBuilderFormulaConcat;
+    Copy: DataBuilderFormulaCopy;
+    Eval: Eval;
+    ExtractDate: DataBuilderFormulaExtractDate;
+    ExtractTime: DataBuilderFormulaExtractTime;
+    FindAppRecordId: DataBuilderFormulaFindAppRecordId;
+    FindExternalRecordId: DataBuilderFormulaFindExternalRecordId;
+    FirstName: DataBuilderFormulaFirstName;
+    LastName: DataBuilderFormulaLastName;
+    Iterate: DataBuilderFormulaIterate;
+    Jsonata: JsonataFormula;
+    DataSchemaRef: DataSchemaRef;
+};
+declare function isFormula(value: any): boolean;
+declare function hasFormulas(value: any): any;
+declare function getFormula(value: any): DataBuilderFormulaBase | undefined;
+export { getFormula as getFormula_internalDoNotUse, isFormula as isFormula_internalDoNotUse, hasFormulas as hasFormulas_internalDoNotUse, };

package/dist/dts/{data-builder/formulas → formulas}/record.d.ts

@@ -1,5 +1,5 @@
 import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
-import { DataRecord } from '../../data-collections';
+import { DataRecord } from '../workspace-elements/base/data-collections';
 export declare class DataBuilderFormulaRecord extends DataBuilderFormulaBase {
     record: DataRecord;
     constructor(record: DataRecord);

package/dist/dts/{data-builder/formulas → formulas}/types.d.ts

@@ -25,3 +25,4 @@ export declare enum DataBuilderFormulaType {
     JSONATA = "jsonata",
     DATA_SCHEMA_REF = "dataSchemaRef"
 }
+export declare const FormulaPropertyKeys: string[];

package/dist/dts/index.d.ts

@@ -1,36 +1,22 @@
 export * from './errors';
 export * from './workspace-elements';
 export * from './workspace-elements-catalog';
-export * from './accessors';
-export * from './actions';
-export * from './app-data-schemas';
-export * from './app-events';
 export * from './auth';
-export * from './connections';
 export * from './connector-copilot';
-export * from './connectors';
 export * from './data-builder';
-export * from './data-collections';
 export * from './data-filter';
+export * from './formulas';
+export * from './locators';
+export * from './error-tools';
 export * from './data-form';
-export * from './data-links';
 export * from './data-schema';
-export * from './data-sources';
+export * from './data-schema-utils';
 export * from './date-time';
 export * from './entity-repository';
-export * from './external-events';
-export * from './field-mappings';
-export * from './flow-runs';
-export * from './flows';
 export * from './http-requests';
 export * from './integration-elements';
-export * from './integrations';
 export * from './logging';
-export * from './screens';
-export * from './udm';
 export * from './usage';
-export * from './users';
-export * from './scenarios';
 export * from './variables';
 export * from './workspaces';
 export * from './apps';
@@ -38,4 +24,5 @@ export * from './workspace-updates';
 export * from './orgs';
 export * from './webhooks';
 export * from './alerts';
+export * from './accessors/';
 export { IntegrationAppClient } from './client';

package/dist/dts/integration-elements/index.d.ts

@@ -1,7 +1,7 @@
-import { Connection } from '../connections';
 import { ErrorData } from '../errors';
-import { Integration } from '../integrations';
-import { Customer } from '../users';
+import { Connection } from '../workspace-elements/api/connections-api';
+import { Customer } from '../workspace-elements/api/customers-api';
+import { Integration } from '../workspace-elements/api/integrations-api';
 export declare enum IntegrationElementLevel {
     UNIVERSAL = "universal",
     CONNECTOR = "connector",

package/dist/dts/{data-builder/locators.d.ts → locators/index.d.ts}

@@ -1,4 +1,5 @@
-import { DataSchema } from '../data-schema';
+import { DataSchema } from '../data-schema/types';
+export declare function makeObjectPropertyLocator(objectLocator: string | undefined, propertyName: string): string;
 export declare enum DataLocatorStepType {
     OBJECT_PROPERTY = "object_property",
     ARRAY_ITEM = "array_item"
@@ -18,9 +19,9 @@ export type DataLocator = DataLocatorStep[] | string;
 export declare class InvalidLocatorError extends Error {
 }
 export declare function locatorToField(locator: string): string;
-export declare function makeObjectPropertyLocator(objectLocator: string | undefined, propertyName: string): string;
 export declare function getLocatorsFromSchema(schema?: DataSchema, rootLocator?: string): string[];
 export declare function getSchemaByLocator(schema: any, locator: DataLocator): any;
+export declare function getValueByLocator(variables: any, locator: DataLocator): any;
 export declare function findValueLocators(data: any, value: any): string[];
 export declare function getValueAtLocator(data: any, locator: DataLocator): any;
 export declare function setValueAtLocator(obj: any, locator: string, value: any): any;
@@ -41,4 +42,3 @@ export declare function locatorToString(locator: DataLocator): string;
 export declare function stepsToLocator(steps: DataLocatorStep[]): string;
 export declare function createObjectFromLocators(locators?: string[], placeholderValue?: string): {};
 export declare function getFormulaLocators(formulaType: string, data: any): string[];
-export declare function transformVariablesWith(data: any, transformFunction: (locator: string) => string): any;

package/dist/dts/variables.d.ts

@@ -1,5 +1,5 @@
 import { DataSchema } from './data-schema';
-import { FlowInstance } from './flows';
+import { FlowInstance } from './workspace-elements/api/flows-api';
 export declare function getNodeInputSchema(flow: FlowInstance, nodeKey: string): any;
 export declare function getFlowNodeConfigTimeVariablesSchema({ parametersSchema, userSchema, }: {
     parametersSchema: DataSchema;

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

@@ -0,0 +1,8 @@
+import { BaseActionInstance } from '../base/action-instances';
+import { BaseAction } from '../base/actions';
+import { BaseCustomer } from '../base/customers';
+export interface ActionInstance extends BaseActionInstance {
+    user?: BaseCustomer;
+    parent?: BaseAction;
+}
+export type ActionInstanceApiResponse = ActionInstance;

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

@@ -0,0 +1,10 @@
+import { BaseActionRunLogRecord } from '../base/action-run-log-records';
+import { BaseAction } from '../base/actions';
+import { BaseConnection } from '../base/connections';
+import { BaseIntegration } from '../base/integrations';
+export interface ActionRunLogRecord extends BaseActionRunLogRecord {
+    action?: BaseAction;
+    integration?: BaseIntegration;
+    connection?: BaseConnection;
+}
+export type ActionRunLogRecordApiResponse = ActionRunLogRecord;

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

@@ -1,43 +1,10 @@
-import { ElementInstanceSelector, IntegrationSpecificElementSelector } from '../accessors';
-import { ConnectionSelector } from '../connections';
-import { DataSchema } from '../data-schema';
-import { PaginationQuery } from '../entity-repository';
-import { OpenConfigurationOptions } from '../iframe';
-import { ElementInstanceFields, ElementTemplateFields } from '../integration-elements';
-import { AppliedToIntegrations } from '../integrations';
-import { ActionType } from './action-types';
-import { WorkspaceElementDependency, WorkspaceElementState } from '../workspace-elements';
-export declare enum ActionDependencyType {
-    FieldMapping = "FieldMapping",
-    DataSource = "DataSource"
-}
-export interface ActionDependency {
-    type: ActionDependencyType;
-    key: string;
-    element?: any;
-}
-export interface Action extends ElementTemplateFields {
-    type: ActionType;
-    inputSchema?: DataSchema;
-    config?: any;
-    outputMapping?: any;
-    customOutputSchema?: DataSchema;
-    defaultOutputSchema?: DataSchema;
-    transformedOutputSchema?: DataSchema;
-    outputSchema?: DataSchema;
-    appliedToIntegrations?: AppliedToIntegrations<Action>;
-    dependencies?: WorkspaceElementDependency[];
-}
-export interface ActionInstance extends ElementInstanceFields {
-    type: ActionType;
-    parent?: Action;
-    instanceKey?: string;
-    inputSchema?: any;
-    config?: any;
-    outputSchema?: any;
-    isOutdated?: boolean;
-    state: WorkspaceElementState;
-}
+import { ConnectionSelector } from './connections-api';
+import { ElementInstanceSelector, IntegrationSpecificElementSelector } from '../../accessors';
+import { PaginationQuery } from '../../entity-repository';
+import { OpenConfigurationOptions } from '../../iframe';
+import { BaseAction } from '../base/actions';
+import { ActionType } from '../base/actions/action-types';
+import { BaseIntegration, AppliedToIntegrations } from '../base/integrations';
 export interface ListActionsForIntegrationQuery extends PaginationQuery {
     parentId?: string | 'null';
 }
@@ -92,3 +59,8 @@ export declare enum ActionRunLogStatus {
     SUCCESS = "success",
     ERROR = "error"
 }
+export interface Action extends BaseAction {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<Action>;
+}
+export type ActionApiResponse = Action;

package/dist/dts/{app-data-schemas/api.d.ts → workspace-elements/api/app-data-schema-instances-api.d.ts}

@@ -1,18 +1,12 @@
-import { PaginationQuery } from '../entity-repository';
-export type CreateAppDataSchemaRequest = {
-    key: string;
-    name: string;
-    schema?: any;
-    code?: string;
-};
-export type UpdateAppDataSchemaRequest = {
-    key?: string;
-    name?: string;
-    schema?: any;
-    code?: string;
-    archivedAt?: string;
-};
-export interface FindAppDataSchemasQuery extends PaginationQuery {
+import { PaginationQuery } from '../../entity-repository';
+import { BaseAppDataSchemaInstance } from '../base/app-data-schema-instances';
+import { BaseAppDataSchema } from '../base/app-data-schemas';
+import { BaseCustomer } from '../base/customers';
+export interface FindAppDataSchemaInstancesQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    appDataSchemaId?: string;
+    instanceKey?: string;
 }
 export interface AppDataSchemaInstanceSelector {
     id?: string;
@@ -25,9 +19,8 @@ export interface UpdateAppDataSchemaInstanceRequest {
 }
 export interface CreateAppDataSchemaInstanceRequest {
 }
-export interface FindAppDataSchemaInstancesQuery extends PaginationQuery {
-    id?: string;
-    userId?: string;
-    appDataSchemaId?: string;
-    instanceKey?: string;
+export interface AppDataSchemaInstance extends BaseAppDataSchemaInstance {
+    user?: BaseCustomer;
+    appDataSchema?: BaseAppDataSchema;
 }
+export type AppDataSchemaInstanceApiResponse = AppDataSchemaInstance;

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

@@ -0,0 +1,19 @@
+import { PaginationQuery } from '../../entity-repository';
+import { BaseAppDataSchema } from '../base/app-data-schemas';
+export interface FindAppDataSchemasQuery extends PaginationQuery {
+}
+export type CreateAppDataSchemaRequest = {
+    key: string;
+    name: string;
+    schema?: any;
+    code?: string;
+};
+export type UpdateAppDataSchemaRequest = {
+    key?: string;
+    name?: string;
+    schema?: any;
+    code?: string;
+    archivedAt?: string;
+};
+export type AppDataSchema = BaseAppDataSchema;
+export type AppDataSchemaApiResponse = AppDataSchema;

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

@@ -0,0 +1,30 @@
+import { ElementInstanceSelector } from '../../accessors';
+import { PaginationQuery } from '../../entity-repository';
+import { BaseAppEventSubscription } from '../base/app-event-subscriptions';
+import { BaseAppEventType } from '../base/app-event-types';
+import { BaseCustomer } from '../base/customers';
+export interface FindAppEventSubscriptionsQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    instanceKey?: string;
+    appEventTypeId?: string;
+    isSubscribed?: boolean;
+}
+export interface CreateAppEventSubscriptionRequest {
+}
+export interface UpdateAppEventSubscriptionRequest {
+}
+export interface AppEventSubscriptionCreateRequest {
+}
+export interface AppEventSubscriptionUpdateRequest {
+}
+export interface AppEventSubscriptionSelector extends Omit<ElementInstanceSelector, 'parentKey' | 'parentId'> {
+    appEventTypeKey?: string;
+    appEventTypeId?: string;
+    instanceKey?: string;
+}
+export interface AppEventSubscription extends BaseAppEventSubscription {
+    appEventType?: BaseAppEventType;
+    user?: BaseCustomer;
+}
+export type AppEventSubscriptionApiResponse = AppEventSubscription;

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

@@ -0,0 +1,30 @@
+import { DataSchema } from '../../data-schema';
+import { PaginationQuery } from '../../entity-repository';
+import { HttpRequestSpec } from '../../http-requests';
+import { BaseAppEventType } from '../base/app-event-types';
+export interface UpdateAppEventTypeRequest {
+    key?: string;
+    name?: string;
+    subscribeRequest?: HttpRequestSpec;
+    example?: any;
+    schema?: DataSchema;
+    userIdFormula?: any;
+}
+export interface CreateAppEventTypeRequest extends UpdateAppEventTypeRequest {
+    key: string;
+    name: string;
+}
+export interface FindAppEventTypesQuery extends PaginationQuery {
+    includeArchived?: boolean;
+}
+export interface FindAppEventsQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    instanceKey?: string;
+    appEventTypeId?: string;
+    appEventSubscriptionId?: string;
+    startDatetime?: string;
+    endDatetime?: string;
+}
+export type AppEventType = BaseAppEventType;
+export type AppEventTypeApiResponse = AppEventType;

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

@@ -0,0 +1,17 @@
+import { BaseAppEventSubscription } from '../base/app-event-subscriptions';
+import { BaseAppEventType } from '../base/app-event-types';
+import { BaseCustomer } from '../base/customers';
+export interface AppEvent {
+    id: string;
+    name?: string;
+    userId: string;
+    user?: BaseCustomer;
+    appEventTypeId: string;
+    appEventType?: BaseAppEventType;
+    appEventSubscriptionId: string;
+    appEventSubscription?: BaseAppEventSubscription;
+    event: any;
+    datetime: string;
+    launchedFlowRunIds: string[];
+}
+export type AppEventApiResponse = AppEvent;

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

@@ -0,0 +1,49 @@
+import { PaginationQuery, PaginationResponse } from '../../entity-repository';
+import { ErrorData } from '../../errors';
+import { BaseConnection } from '../base/connections';
+import { BaseCustomer } from '../base/customers';
+import { BaseIntegration } from '../base/integrations';
+export interface FindConnectionsQuery extends PaginationQuery {
+    userId?: string;
+    isTest?: boolean;
+    integrationKey?: string;
+    integrationId?: string;
+    includeArchived?: boolean;
+}
+export declare class CreateConnectionRequest {
+    name: string;
+    integrationId: string;
+    credentials?: string;
+}
+export declare class UpdateConnectionRequest {
+    name?: string;
+    credentials?: string;
+    accessToken?: string;
+}
+export declare class FindConnectionsResponse extends PaginationResponse<Connection> {
+}
+export interface ConnectionSelector {
+    id?: string;
+    integrationKey?: string;
+    integrationId?: string;
+    connectionId?: string;
+}
+export interface Connection extends BaseConnection {
+    user?: BaseCustomer;
+    integration?: BaseIntegration;
+}
+export type ConnectionApiResponse = Connection;
+export type ConnectionMessagePayload = {
+    source: string;
+    requestId: string;
+} & ({
+    type: 'newConnectionCreated';
+    connection: Connection;
+    error?: never;
+    errorData?: never;
+} | {
+    type: 'newConnectionFailure';
+    connection?: never;
+    error: string;
+    errorData?: ErrorData;
+});

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

@@ -1,4 +1,5 @@
-import { PaginationQuery, SearchQuery } from '../entity-repository';
+import { PaginationQuery, SearchQuery } from '../../entity-repository';
+import { BaseCustomer } from '../base/customers';
 export type CreateCustomerRequest = {
     name?: string;
     internalId: string;
@@ -21,3 +22,6 @@ export type CreateUserRequest = CreateCustomerRequest;
 export type UpdateUserRequest = UpdateCustomerRequest;
 export type FindUsersQuery = FindCustomersQuery;
 export type UserSelector = CustomerSelector;
+export type Customer = BaseCustomer;
+export type CustomerApiResponse = Customer;
+export type User = Customer;