@membranehq/sdk 0.3.0 → 0.5.0

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

@@ -11,6 +11,8 @@ export interface App {
     popularity: number;
     uuid: string;
     knowledgeBaseUuid?: string;
+    hasFreeTestAccount?: boolean;
+    freeTestAccountGuide?: string;
 }
 export interface AppCategory {
     count: number;

package/dist/dts/auth/accessors.d.ts

@@ -1,5 +1,5 @@
 import { IntegrationAppApiClient } from '../api-client';
-import { Customer } from '../users';
+import { Customer } from '../workspace-elements/api/customers-api';
 export declare class SelfAccessor {
     private client;
     constructor(client: IntegrationAppApiClient);

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

@@ -1,4 +1,4 @@
-import { User } from '../users';
+import { User } from '../workspace-elements/api/customers-api';
 import { Workspace } from '../workspaces';
 export * from './accessors';
 export interface Self {

package/dist/dts/client.d.ts

@@ -1,21 +1,8 @@
-import { ActionAccessor, ActionInstanceAccessor, ActionInstancesAccessor, ActionInstanceSelector, ActionsAccessor, ActionSelector } from './actions';
+import { AppDataSchemaAccessor, AppDataSchemaInstanceAccessor, AppDataSchemaInstancesAccessor, AppDataSchemasAccessor, AppEventSubscriptionAccessor, AppEventSubscriptionsAccessor, AppEventTypeAccessor, AppEventTypesAccessor, DataLinkTableAccessor, DataLinkTableInstanceAccessor, DataLinkTableInstancesAccessor, DataLinkTablesAccessor, FieldMappingAccessor, FieldMappingInstanceAccessor, FieldMappingInstancesAccessor, FieldMappingsAccessor, FlowAccessor, FlowInstanceAccessor, FlowInstancesAccessor, FlowsAccessor, FlowRunAccessor, FlowRunsAccessor, ExternalEventSubscriptionAccessor, ExternalEventSubscriptionsAccessor, DataSourceAccessor, DataSourceInstanceAccessor, DataSourceInstancesAccessor, DataSourcesAccessor, ConnectionAccessor, ConnectionsAccessor, ActionAccessor, ActionInstanceAccessor, ActionInstancesAccessor, ActionsAccessor, IntegrationAccessor, IntegrationsAccessor, ScenarioAccessor, ScenariosAccessor, ScreenAccessor, ScreensAccessor, CustomerAccessor, CustomersAccessor } from './accessors/index';
 import { IntegrationAppApiClient, IntegrationAppClientOptions } from './api-client';
-import { AppDataSchemaAccessor, AppDataSchemaInstanceAccessor, AppDataSchemaInstanceSelector, AppDataSchemaInstancesAccessor, AppDataSchemasAccessor } from './app-data-schemas';
-import { AppEventSubscriptionAccessor, AppEventSubscriptionSelector, AppEventSubscriptionsAccessor, AppEventTypeAccessor, AppEventTypesAccessor, AppEventsAccessor } from './app-events';
 import { SelfAccessor } from './auth';
-import { ConnectionAccessor, ConnectionsAccessor } from './connections';
-import { DataLinkTableAccessor, DataLinkTableInstanceAccessor, DataLinkTableInstanceSelector, DataLinkTableInstancesAccessor, DataLinkTablesAccessor } from './data-links';
-import { DataSourceAccessor, DataSourceInstanceAccessor, DataSourceInstanceSelector, DataSourceInstancesAccessor, DataSourceSelector, DataSourcesAccessor } from './data-sources';
-import { ExternalEventSubscriptionAccessor, ExternalEventSubscriptionsAccessor } from './external-events';
-import { FieldMappingAccessor, FieldMappingInstanceAccessor, FieldMappingInstanceSelector, FieldMappingInstancesAccessor, FieldMappingSelector, FieldMappingsAccessor } from './field-mappings';
-import { FlowRunAccessor, FlowRunsAccessor } from './flow-runs';
-import { FlowAccessor, FlowInstanceAccessor, FlowInstanceSelector, FlowInstancesAccessor, FlowSelector, FlowsAccessor } from './flows';
 import { OpenConfigurationOptions } from './iframe';
-import { IntegrationAccessor, IntegrationsAccessor } from './integrations';
-import { ScenarioAccessor, ScenariosAccessor } from './scenarios';
-import { ScreenSelector } from './screens';
-import { ScreenAccessor, ScreensAccessor } from './screens/accessors';
-import { CustomerAccessor, CustomersAccessor, CustomerSelector } from './users';
+import { FlowInstanceSelector, FlowSelector, DataSourceInstanceSelector, DataSourceSelector, ActionInstanceSelector, ActionSelector, ScreenSelector, CustomerSelector, AppDataSchemaInstanceSelector, AppEventSubscriptionSelector, DataLinkTableInstanceSelector, FieldMappingInstanceSelector, FieldMappingSelector } from './workspace-elements/api';
 interface OpenIntegrationAppConfigurationOptions extends OpenConfigurationOptions {
 }
 export declare class IntegrationAppClient extends IntegrationAppApiClient {
@@ -54,7 +41,6 @@ export declare class IntegrationAppClient extends IntegrationAppApiClient {
     appEventType(id: string): AppEventTypeAccessor;
     get appEventSubscriptions(): AppEventSubscriptionsAccessor;
     appEventSubscription(selector: string | AppEventSubscriptionSelector): AppEventSubscriptionAccessor;
-    get appEvents(): AppEventsAccessor;
     get flowRuns(): FlowRunsAccessor;
     flowRun(id: string): FlowRunAccessor;
     get appDataSchemas(): AppDataSchemasAccessor;
@@ -65,6 +51,7 @@ export declare class IntegrationAppClient extends IntegrationAppApiClient {
     get customers(): CustomersAccessor;
     scenario(selector: string): ScenarioAccessor;
     get scenarios(): ScenariosAccessor;
+    createEventSource(uri: string, queryParams?: Record<string, any>): Promise<EventSource>;
     connectionRequest(connectionId: string, uri: string, data?: any): Promise<any>;
 }
 export {};

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

@@ -1,9 +1,19 @@
-export * from './formula-processors';
-export * from './formula-types';
-export * as Formula from './formulas';
-export { CaseFormulaValue, CaseFormulaValueItem } from './formulas/case';
-export { EvalOperator } from './formulas/eval';
-export { LookupValue } from './formulas/base';
-export { MappingItem } from './formulas/map';
-export { DataBuilderFormulaType } from './formulas/types';
-export * from './locators';
+import { DataSchema } from '../data-schema/types';
+import { DataBuilderFormulaBase, ResolveFormulaParams } from '../formulas/base';
+declare let getFormula: (value: any) => DataBuilderFormulaBase | undefined;
+declare let isFormula: (value: any) => boolean;
+declare let hasFormulas: (value: any) => boolean;
+export declare function injectFormulaCatalog(getFormulaFn: any, isFormulaFn: any, hasFormulasFn: any): void;
+export { getFormula };
+export { isFormula };
+export { hasFormulas };
+export declare function buildData(value: any, variables?: any): any;
+export declare function buildValue(value: any, variables: any): any;
+export declare function resolveValue<T = unknown>(value: unknown, params: ResolveFormulaParams): Promise<T>;
+export declare function transformVars(value: any, transformations: Record<string, any>): any;
+export declare function valueToString(value: any, variablesSchema: any): string;
+export declare function resolveFormulas<T = unknown>(value: any, params: ResolveFormulaParams): Promise<T>;
+export declare function processCopy(data: any): any;
+export declare function getVariableLocators(data: any): string[];
+export declare function removeNonExistentVars(value: any, schema: DataSchema): any;
+export declare function transformVariablesWith(data: any, transformFunction: (locator: string) => string): any;

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,6 +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/types.d.ts

@@ -1,4 +1,4 @@
-import { DataRecord } from '../data-collections';
+import { z } from 'zod';
 export interface DataSchema {
     title?: string;
     description?: string;
@@ -10,9 +10,9 @@ export interface DataSchema {
     items?: DataSchema;
     additionalProperties?: boolean | DataSchema;
     enum?: string[];
-    referenceRecords?: DataRecord[];
+    referenceRecords?: any[];
     referenceCollection?: {
-        key: any;
+        key?: any;
         parameters?: Record<string, any>;
     };
     referenceUdm?: string;
@@ -34,3 +34,4 @@ export interface DataSchema {
     referenceCollectionPath?: string;
     referenceCollectionUri?: string;
 }
+export declare const DataSchema: z.ZodType<DataSchema>;

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/entity-repository.d.ts

@@ -1,23 +1,90 @@
-export type CommonListElementsQuery = SearchQuery & PaginationQuery & IncludeArchivedQuery;
-export type CommonInstancesListQuery = CommonListElementsQuery & {
-    userId?: string;
-    instanceKey?: string;
-};
-export type CommonIntegrationOrConnectionQuery = {
-    connectionId?: string;
-    integrationId?: string;
-    integrationKey?: string;
-};
-export type IncludeArchivedQuery = {
-    includeArchived?: boolean;
-};
-export type SearchQuery = {
-    search?: string;
-};
-export type PaginationQuery = {
-    limit?: number;
-    cursor?: string;
-};
+import { z } from 'zod';
+export declare const IncludeArchivedQuery: z.ZodObject<{
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    includeArchived?: boolean | undefined;
+}, {
+    includeArchived?: boolean | undefined;
+}>;
+export type IncludeArchivedQuery = z.infer<typeof IncludeArchivedQuery>;
+export declare const SearchQuery: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+}, {
+    search?: string | undefined;
+}>;
+export type SearchQuery = z.infer<typeof SearchQuery>;
+export declare const PaginationQuery: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}, {
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}>;
+export type PaginationQuery = z.infer<typeof PaginationQuery>;
+export declare const CommonListElementsQuery: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+} & {
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+} & {
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    includeArchived?: boolean | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}, {
+    search?: string | undefined;
+    includeArchived?: boolean | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}>;
+export type CommonListElementsQuery = z.infer<typeof CommonListElementsQuery>;
+export declare const CommonInstancesListQuery: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+} & {
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+} & {
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+} & {
+    userId: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    includeArchived?: boolean | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    userId?: string | undefined;
+    instanceKey?: string | undefined;
+}, {
+    search?: string | undefined;
+    includeArchived?: boolean | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    userId?: string | undefined;
+    instanceKey?: string | undefined;
+}>;
+export type CommonInstancesListQuery = z.infer<typeof CommonInstancesListQuery>;
+export declare const CommonIntegrationOrConnectionQuery: z.ZodObject<{
+    connectionId: z.ZodOptional<z.ZodString>;
+    integrationId: z.ZodOptional<z.ZodString>;
+    integrationKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    connectionId?: string | undefined;
+    integrationId?: string | undefined;
+    integrationKey?: string | undefined;
+}, {
+    connectionId?: string | undefined;
+    integrationId?: string | undefined;
+    integrationKey?: string | undefined;
+}>;
+export type CommonIntegrationOrConnectionQuery = z.infer<typeof CommonIntegrationOrConnectionQuery>;
 export declare class PaginationResponse<T> {
     items: T[];
     cursor?: string;

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 { z } from 'zod';
-import { WorkspaceElementReference } from '../workspace-elements';
-export * from './error-doc-enum';
 export declare enum ErrorType {
     BAD_REQUEST = "bad_request",
     CONNECTION = "connection",
@@ -33,7 +31,7 @@ export declare enum ConcurrencyErrorKey {
 export declare const ErrorDataSchema: any;
 interface ErrorDataFields extends z.infer<typeof ErrorDataSchema> {
 }
-type ErrorConstructorArg = string | ErrorDataFields | Error;
+export type ErrorConstructorArg = string | ErrorDataFields | Error;
 export declare function isIntegrationAppError(error: any): any;
 export declare class ErrorData implements ErrorDataFields {
     constructor(arg: ErrorConstructorArg);
@@ -57,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);
 }
@@ -93,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<any>;
-    resolveDataCollection(args: DataSchemaRegArgsDataCollection, params: ResolveFormulaParams): Promise<any>;
-    resolveInternalDataSchema(args: DataSchemaRegArgsInternalDataSchema, params: ResolveFormulaParams): Promise<import("../..").DataSchema | 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>;
     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/http-requests.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export declare enum HttpRequestMethod {
     GET = "GET",
     POST = "POST",
@@ -5,13 +6,26 @@ export declare enum HttpRequestMethod {
     PUT = "PUT",
     DELETE = "DELETE"
 }
-export interface HttpRequestSpec {
-    method?: HttpRequestMethod;
-    uri: any;
-    headers?: Record<string, any>;
-    query?: Record<string, any>;
+export declare const HttpRequestSpec: z.ZodObject<{
+    method: z.ZodOptional<z.ZodNativeEnum<typeof HttpRequestMethod>>;
+    uri: z.ZodAny;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    body: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    headers?: Record<string, any> | undefined;
+    method?: HttpRequestMethod | undefined;
     body?: any;
-}
+    uri?: any;
+    query?: Record<string, any> | undefined;
+}, {
+    headers?: Record<string, any> | undefined;
+    method?: HttpRequestMethod | undefined;
+    body?: any;
+    uri?: any;
+    query?: Record<string, any> | undefined;
+}>;
+export type HttpRequestSpec = z.infer<typeof HttpRequestSpec>;
 export declare const HTTP_REQUEST_SCHEMA: {
     type: string;
     properties: {

package/dist/dts/iframe.d.ts

@@ -1,8 +1,16 @@
+import { z } from 'zod';
 export declare const POPUP_ELEMENT_ID = "__integration-app-popup";
-export interface OpenConfigurationOptions {
-    onClose?: () => void;
-    showPoweredBy?: boolean;
-}
+export declare const OpenConfigurationOptions: z.ZodObject<{
+    onClose: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    showPoweredBy: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    onClose?: ((...args: unknown[]) => unknown) | undefined;
+    showPoweredBy?: boolean | undefined;
+}, {
+    onClose?: ((...args: unknown[]) => unknown) | undefined;
+    showPoweredBy?: boolean | undefined;
+}>;
+export type OpenConfigurationOptions = z.infer<typeof OpenConfigurationOptions>;
 export type OpenIframeOptions = OpenConfigurationOptions & {
     [key: string]: (...args: any[]) => void;
 };

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,6 @@ export * from './workspace-updates';
 export * from './orgs';
 export * from './webhooks';
 export * from './alerts';
+export * from './accessors';
+export * from './sse';
 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/sse/index.d.ts

@@ -0,0 +1 @@
+export * from './workspace-elements';

package/dist/dts/sse/workspace-elements.d.ts

@@ -0,0 +1,9 @@
+import { WorkspaceElementType } from '../workspace-elements';
+export declare enum WorkspaceSyncEventType {
+    ElementUpdate = "element-update"
+}
+export interface WorkspaceSyncEvent {
+    type: WorkspaceSyncEventType;
+    elementType: WorkspaceElementType;
+    elementId: string;
+}

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;