@membranehq/sdk 0.1.0

package/dist/dts/connectors/methods.d.ts

@@ -0,0 +1,44 @@
+import { GraphQLApiMapping } from './graphql-api';
+import { OperationMapping } from './operations';
+import { RestApiMapping } from './rest-api';
+import { DataSchema } from '../data-schema';
+export declare enum ConnectorMethodImplementationType {
+    mapping = "mapping",
+    operationMapping = "operation-mapping",
+    restApiMapping = "rest-api-mapping",
+    graphqlApiMapping = "graphql-api-mapping",
+    javascript = "javascript",
+    notSupported = "not-supported"
+}
+export type ConnectorMethodImplementation = ConnectorMethodImplementationBase | ConnectorMethodImplementationMapping | ConnectorMethodImplementationOperationMapping | ConnectorMethodImplementationRestApiMapping | ConnectorMethodImplementationGraphqlApiMapping | ConnectorMethodImplementationJavascript | ConnectorMethodImplementationNotSupported;
+export declare const CONNECTOR_METHOD_IMPLEMENTATION_SUFFIXES: Partial<Record<ConnectorMethodImplementationType, string[]>>;
+export interface ConnectorMethodImplementationBase {
+    implementationType?: ConnectorMethodImplementationType;
+    filePath?: string;
+    inheritedFromPath?: string[];
+    isIncomplete?: boolean;
+    parametersSchema?: DataSchema;
+}
+export interface ConnectorMethodImplementationMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.mapping;
+    mapping: any;
+}
+export interface ConnectorMethodImplementationOperationMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.operationMapping;
+    mapping: OperationMapping;
+}
+export interface ConnectorMethodImplementationRestApiMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.restApiMapping;
+    mapping: RestApiMapping;
+}
+export interface ConnectorMethodImplementationGraphqlApiMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.graphqlApiMapping;
+    mapping: GraphQLApiMapping;
+}
+export interface ConnectorMethodImplementationJavascript extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.javascript;
+    code: string;
+}
+export interface ConnectorMethodImplementationNotSupported extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.notSupported;
+}

package/dist/dts/connectors/openapi.d.ts

@@ -0,0 +1,11 @@
+export interface OpenapiMapping {
+    path: string;
+    method: string;
+    requestMapping: {
+        pathParameters?: any;
+        query?: any;
+        data?: any;
+        headers?: any;
+    };
+    responseMapping?: any;
+}

package/dist/dts/connectors/operations/handlers.d.ts

@@ -0,0 +1,9 @@
+import { ConnectorMethodImplementation, ConnectorMethodImplementationBase, ConnectorMethodImplementationType } from '../methods';
+import { OperationSpec } from './types';
+export type ConnectorOperationMethod<ImplementationFields extends ConnectorMethodImplementation | ConnectorMethodImplementationBase = ConnectorMethodImplementationBase> = {
+    isIncomplete?: boolean;
+} & ImplementationFields;
+export declare const ConnectorOperationMethodImplementationTypes: ConnectorMethodImplementationType[];
+export interface ConnectorOperationHandler extends OperationSpec {
+    methods?: Record<'run', ConnectorOperationMethod>;
+}

package/dist/dts/connectors/operations/index.d.ts

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

package/dist/dts/connectors/operations/types.d.ts

@@ -0,0 +1,26 @@
+interface OperationBase {
+    key: string;
+    name: string;
+    isReadOnly?: boolean;
+    description?: string;
+    tags?: string[];
+}
+export interface OperationListItem extends OperationBase {
+}
+export interface OperationSpec extends OperationBase {
+    inputSchema?: any;
+    outputSchema?: any;
+    isReadOnly?: boolean;
+}
+export interface OperationRunRequest {
+    input: any;
+}
+export interface OperationRunResponse {
+    output?: any;
+}
+export interface OperationMapping {
+    operationKey: string;
+    inputMapping?: any;
+    outputMapping?: any;
+}
+export {};

package/dist/dts/connectors/rest-api.d.ts

@@ -0,0 +1,67 @@
+import https from 'https';
+import { HttpRequestMethod } from '../http-requests';
+export interface RestApiClientInput {
+    path: string;
+    method: HttpRequestMethod;
+    query?: Record<string, string>;
+    data?: any;
+    headers?: Record<string, string>;
+    responseType?: 'arraybuffer' | 'stream';
+    returnFullResponse?: boolean;
+}
+export interface RestApiClientOutput {
+    status: number;
+    headers?: Record<string, string>;
+    data?: any;
+}
+export interface RestApiMapping {
+    path: string;
+    method: string;
+    requestMapping: {
+        pathParameters?: any;
+        query?: any;
+        data?: any;
+        headers?: any;
+    };
+    responseMapping?: any;
+}
+export interface RestApiClientResponseHandler {
+    match: any;
+    isSuccess: boolean;
+    error?: any;
+}
+export interface RestApiClientOverride {
+    match: {
+        path: string;
+        method: string;
+    };
+    patch?: {
+        query?: Record<string, string>;
+        data?: any;
+        headers?: Record<string, string>;
+    };
+}
+export interface RestApiClientOptions {
+    baseUri?: any;
+    proxyUri?: any;
+    headers?: {
+        [key: string]: any;
+    };
+    auth?: {
+        username: any;
+        password: any;
+    };
+    query?: {
+        [key: string]: any;
+    };
+    returnFullResponse?: boolean;
+    responseHandlers?: Array<RestApiClientResponseHandler>;
+    dynamicOptions?: (input: RestApiClientInput) => RestApiClientOptions;
+    binary?: boolean;
+    stream?: boolean;
+    onError?: (error: any) => any;
+}
+export interface RestApiClientConstructorOptions extends RestApiClientOptions {
+    overrides?: RestApiClientOverride[];
+    httpsAgent?: https.Agent;
+}

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

@@ -0,0 +1,75 @@
+import { DataSchema } from '../data-schema';
+import { UDM } from '../udm';
+import { ConnectorAuth } from './auth';
+import { DataLocation, DataLocationSpec } from './data-locations';
+import { ConnectorMethodImplementation } from './methods';
+import { ConnectorOperationHandler } from './operations';
+import { ConnectorUdmSpec } from './udm';
+export declare const CONNECTOR_CATEGORIES: readonly ["Accounting", "Ads", "Analytics", "ATS", "Communication", "CRM", "Customer Success", "Document Management", "E-Commerce", "E-Signature", "ERP", "File Storage", "HRIS", "Legal", "Marketing Automation", "Payments", "Project Management", "Sales", "Ticketing"];
+export type Connector = ConnectorSpec & {
+    id: string;
+    uuid: string;
+    key: string;
+    name: string;
+    categories: string[];
+    logoUri: string;
+    baseUri: string;
+    revision?: string;
+    status: ConnectorStatus;
+    hasReadme?: boolean;
+    hasTest?: boolean;
+    hasOperations?: boolean;
+    hasData?: boolean;
+    udms?: string[];
+    isReadOnly?: boolean;
+    workspaceId?: string;
+};
+export declare enum ConnectorStatus {
+    production = "production",
+    beta = "beta",
+    planned = "planned"
+}
+export interface ConnectorUiSpec {
+    schema?: DataSchema;
+    description?: string;
+    helpUri?: string;
+    test?: boolean;
+}
+export type ConnectorDataUdmSpec = {
+    rootLocation: DataLocation;
+};
+export type ConnectorDataSpec = {
+    rootLocation?: DataLocation;
+    locations?: DataLocationSpec[];
+    udm?: Partial<Record<UDM, ConnectorDataUdmSpec>>;
+    root?: DataLocation;
+} & Partial<Record<UDM, DataLocation>>;
+export type ConnectorApiType = 'openapi' | 'graphql';
+export interface ConnectorSpec {
+    key?: string;
+    name?: string;
+    appUri?: string;
+    logoUri?: string;
+    apiDocsUri?: string;
+    api?: {
+        type: ConnectorApiType;
+    };
+    ui?: ConnectorUiSpec;
+    auth?: ConnectorAuth;
+    parametersSchema?: DataSchema;
+    data?: ConnectorDataSpec;
+    udms?: string[];
+    udm?: Record<string, ConnectorUdmSpec>;
+    operations?: ConnectorOperationHandler[];
+    test?: ConnectorMethodImplementation;
+    hasReadme?: boolean;
+    appUuid?: string;
+    knowledgeBaseUuid?: string;
+    workspaceId?: string;
+}
+export type MinimalConnector = {
+    id: string;
+    key: string;
+    name: string;
+    logoUri: string;
+};

package/dist/dts/connectors/udm.d.ts

@@ -0,0 +1,14 @@
+import { DataLocationPointer } from './data-locations';
+export interface ConnectorUdmListLitem {
+    key: string;
+}
+export interface ConnectorUdmSpec {
+    defaultCollection?: DataLocationPointer;
+    rootDirectory?: DataLocationPointer;
+    collectionMappings: ConnectorUdmCollectionMapping[];
+}
+export interface ConnectorUdmCollectionMapping extends DataLocationPointer {
+    fieldsToCollection?: any;
+    fieldsFromCollection?: any;
+}
+export declare function findUdmCollectionMapping(udm: ConnectorUdmSpec, collectionKey: string, parameters?: Record<string, any>): ConnectorUdmCollectionMapping | undefined;

package/dist/dts/data-builder/formula-processors.d.ts

@@ -0,0 +1,13 @@
+import { DataSchema } from '../data-schema';
+import { ResolveFormulaParams } from './formulas/base';
+import { DataLocator } from './locators';
+export declare function buildData(value: any, variables?: any): any;
+export declare function resolveFormulas<T = unknown>(value: any, params: ResolveFormulaParams): Promise<T>;
+export declare function resolveValue<T = unknown>(value: unknown, params: ResolveFormulaParams): Promise<T>;
+export declare function valueToString(value: any, variablesSchema: any): string;
+export declare function buildValue(value: any, variables: any): any;
+export declare function processCopy(data: any): any;
+export declare function getVariableLocators(data: any): string[];
+export declare function transformVars(value: any, transformations: Record<string, any>): any;
+export declare function removeNonExistentVars(value: any, schema: DataSchema): any;
+export declare function getValueByLocator(variables: any, locator: DataLocator): any;

package/dist/dts/data-builder/formula-processors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formula-types.d.ts

@@ -0,0 +1,4 @@
+import { Formula } from '.';
+export declare function isFormula(value: any): boolean;
+export declare function hasFormulas(value: any): any;
+export declare function getFormula(value: any): Formula.Base;

package/dist/dts/data-builder/formulas/and.d.ts

@@ -0,0 +1,9 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class And extends DataBuilderFormulaBase {
+    constructor(args: any[]);
+    getValue(variables: any): boolean | undefined;
+    resolveValue(params: ResolveFormulaParams): Promise<boolean | undefined>;
+    getSchema(): {
+        type: string;
+    };
+}

package/dist/dts/data-builder/formulas/and.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,47 @@
+import { DataBuilderFormulaType } from './types';
+import { DataCollectionSpec } from '../../connectors';
+import { DataSchema } from '../../data-schema';
+export interface LookupValue {
+    query: Record<string, any>;
+    createIfNotFound?: boolean;
+    create?: {
+        fields: any;
+    };
+}
+export interface DataBuilderFormula {
+    resolveValue(params: ResolveFormulaParams): Promise<unknown>;
+    getValue(variables: any): any;
+    getSchema(variablesSchema: any): any;
+    toObject(): any;
+    toString(variablesSchema?: any): string;
+}
+export interface ResolveFormulaParams {
+    variables?: unknown;
+    schema?: DataSchema | undefined;
+    getDataCollection?: (key: string, parameters?: Record<string, unknown>) => Promise<DataCollectionSpec>;
+    getInternalDataSchema?: (key: string) => Promise<DataSchema>;
+    resolveImportDataLink?: (options: {
+        dataLinkTableKey: string;
+        recordId: string;
+    }) => Promise<string | undefined>;
+    resolveExportDataLink?: (options: {
+        dataLinkTableKey: string;
+        recordId: string;
+    }) => Promise<string | undefined>;
+    resolveLookup?: ({ lookup, schema, }: {
+        lookup: LookupValue;
+        schema: DataSchema | undefined;
+    }) => Promise<string | undefined>;
+}
+export declare abstract class DataBuilderFormulaBase<ArgsType = any> implements DataBuilderFormula {
+    type: DataBuilderFormulaType;
+    args: ArgsType;
+    constructor(type: DataBuilderFormulaType, args: ArgsType);
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    abstract getSchema(variablesSchema: any): any;
+    toObject(): any;
+    toString(_variablesSchema?: any): string;
+    getVariableLocators(): string[];
+    transformVars(transformations: any): any;
+    abstract getValue(variables: any): any;
+}

package/dist/dts/data-builder/formulas/case.d.ts

@@ -0,0 +1,18 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export interface CaseFormulaValueItem {
+    filter?: any;
+    value?: any;
+}
+export type CaseFormulaValue = {
+    cases: CaseFormulaValueItem[];
+    default?: any;
+};
+export declare class DataBuilderFormulaCase extends DataBuilderFormulaBase {
+    value: CaseFormulaValue;
+    constructor(value: CaseFormulaValueItem[] | CaseFormulaValue);
+    getValue(variables: any): any;
+    resolveValue(params: ResolveFormulaParams): Promise<unknown>;
+    getSchema(variablesSchema: any): any;
+    isValueValid(): boolean;
+    transformVars(transformations: any): any;
+}

package/dist/dts/data-builder/formulas/case.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/concat.d.ts

@@ -0,0 +1,19 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+type AnyValue = any;
+type ConcatFormulaOptions = {
+    delimiter?: AnyValue;
+    values?: AnyValue[];
+};
+export declare class DataBuilderFormulaConcat extends DataBuilderFormulaBase {
+    options: ConcatFormulaOptions | null;
+    delimiter: AnyValue;
+    values: AnyValue[];
+    constructor(options: ConcatFormulaOptions | null);
+    getValue(variables: any): string | undefined;
+    resolveValue(params: ResolveFormulaParams): Promise<string | undefined>;
+    getSchema(): {
+        type: string;
+    };
+    toString(variablesSchema: any): string;
+}
+export {};

package/dist/dts/data-builder/formulas/concat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/copy.d.ts

@@ -0,0 +1,10 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class DataBuilderFormulaCopy extends DataBuilderFormulaBase {
+    locator: string;
+    constructor(locator: string);
+    getValue(variables: any): {
+        $copy: any;
+    };
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    getSchema(): null;
+}

package/dist/dts/data-builder/formulas/copy.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export interface DataSchemaRegArgsDataCollection {
+    type: 'data-collection';
+    key: unknown;
+    parameters?: unknown;
+}
+export interface DataSchemaRegArgsInternalDataSchema {
+    type: 'internal-data-schema';
+    key: unknown;
+}
+export type DataSchemaRefArgs = DataSchemaRegArgsDataCollection | DataSchemaRegArgsInternalDataSchema;
+export declare class DataSchemaRef extends DataBuilderFormulaBase<DataSchemaRefArgs> {
+    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>;
+    getSchema(): {
+        type: string;
+    };
+}

package/dist/dts/data-builder/formulas/dataSchemaRef.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/domainFromEmail.d.ts

@@ -0,0 +1,10 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class DomainFromEmail extends DataBuilderFormulaBase {
+    value: any;
+    constructor(value: any);
+    getValue(variables: any): string | undefined;
+    resolveValue(params: ResolveFormulaParams): Promise<string | undefined>;
+    getSchema(): {
+        type: string;
+    };
+}

package/dist/dts/data-builder/formulas/domainFromEmail.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+import { DataSchema } from '../../data-schema';
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export interface EvalOperator {
+    key: string;
+    name: string;
+    operandSchema: any;
+    hasOperand: boolean;
+}
+export declare class Eval extends DataBuilderFormulaBase {
+    value: any;
+    operatorKey: string;
+    operand: any;
+    constructor(args: any, formulaValue: any);
+    getAvailableOperators(variablesSchema: DataSchema): EvalOperator[];
+    getOperator(variablesSchema: any): EvalOperator;
+    getValue(variables: any): boolean;
+    resolveValue(params: ResolveFormulaParams): Promise<boolean>;
+    getSchema(): {
+        type: string;
+    };
+    toObject(): {
+        $eval: any;
+    };
+    transformVars(transformations: any): {
+        [x: string]: any;
+        $eval: any;
+    } | undefined;
+}

package/dist/dts/data-builder/formulas/eval.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/extractDate.d.ts

@@ -0,0 +1,11 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class DataBuilderFormulaExtractDate extends DataBuilderFormulaBase {
+    value: any;
+    constructor(value: any);
+    getValue(variables: any): string | undefined;
+    resolveValue(params: ResolveFormulaParams): Promise<string | undefined>;
+    getSchema(): {
+        type: string;
+        format: string;
+    };
+}

package/dist/dts/data-builder/formulas/extractDate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/extractTime.d.ts

@@ -0,0 +1,11 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class DataBuilderFormulaExtractTime extends DataBuilderFormulaBase {
+    value: any;
+    constructor(value: any);
+    getValue(variables: any): string;
+    resolveValue(params: ResolveFormulaParams): Promise<string | undefined>;
+    getSchema(): {
+        type: string;
+        format: string;
+    };
+}

package/dist/dts/data-builder/formulas/extractTime.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import { DataLinkTableConfig } from '../../data-links';
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export interface FindAppRecordIdArgs {
+    dataLinkTable: DataLinkTableConfig;
+    recordId: string;
+}
+export declare class DataBuilderFormulaFindAppRecordId extends DataBuilderFormulaBase {
+    args: FindAppRecordIdArgs;
+    constructor(args: FindAppRecordIdArgs);
+    getValue(variables: any): {
+        $findAppRecordId: any;
+    };
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    getSchema(): {
+        type: string;
+    };
+}

package/dist/dts/data-builder/formulas/findAppRecordId.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import { DataLinkTableConfig } from '../../data-links';
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export interface FindExternalRecordIdArgs {
+    dataLinkTable: DataLinkTableConfig;
+    recordId: string;
+}
+export declare class DataBuilderFormulaFindExternalRecordId extends DataBuilderFormulaBase {
+    args: FindExternalRecordIdArgs;
+    constructor(args: FindExternalRecordIdArgs);
+    getValue(variables: any): {
+        $findExternalRecordId: any;
+    };
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    getSchema(): {
+        type: string;
+    };
+}

package/dist/dts/data-builder/formulas/findExternalRecordId.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/first-name.d.ts

@@ -0,0 +1,10 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class DataBuilderFormulaFirstName extends DataBuilderFormulaBase {
+    value: any;
+    constructor(value: any);
+    getValue(variables: any): any;
+    resolveValue(params: ResolveFormulaParams): Promise<string | undefined>;
+    getSchema(): {
+        type: string;
+    };
+}

package/dist/dts/data-builder/formulas/first-name.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/firstNotEmpty.d.ts

@@ -0,0 +1,7 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class FirstNotEmpty extends DataBuilderFormulaBase {
+    constructor(args: any[]);
+    getValue(variables: any): any;
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    getSchema(variablesSchema: any): any;
+}

package/dist/dts/data-builder/formulas/firstNotEmpty.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/formula.d.ts

@@ -0,0 +1,8 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export declare class FormulaFormula extends DataBuilderFormulaBase {
+    constructor(args: any);
+    getValue(variables: any): any;
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    getSchema(): undefined;
+    transformVars(transformations: any): any;
+}

package/dist/dts/data-builder/formulas/formula.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,26 @@
+export { And } from './and';
+export { DataBuilderFormulaBase as Base } from './base';
+export { DataBuilderFormulaCase as Case } from './case';
+export { DataBuilderFormulaConcat as Concat } from './concat';
+export { DataBuilderFormulaCopy as Copy } from './copy';
+export { DomainFromEmail } from './domainFromEmail';
+export { Eval } from './eval';
+export { DataBuilderFormulaExtractDate as ExtractDate } from './extractDate';
+export { DataBuilderFormulaExtractTime as ExtractTime } from './extractTime';
+export { DataBuilderFormulaFindAppRecordId as FindAppRecordId } from './findAppRecordId';
+export { DataBuilderFormulaFindExternalRecordId as FindExternalRecordId } from './findExternalRecordId';
+export { DataBuilderFormulaFirstName as FirstName } from './first-name';
+export { FirstNotEmpty } from './firstNotEmpty';
+export { FormulaFormula as Formula } from './formula';
+export { DataBuilderFormulaIterate as Iterate } from './iterate';
+export { JsonataFormula as Jsonata } from './jsonata';
+export { DataBuilderFormulaLastName as LastName } from './last-name';
+export { DataBuilderFormulaLookup as Lookup } from './lookup';
+export { DataBuilderFormulaMap as Map } from './map';
+export { MergeObjects } from './mergeObjects';
+export { Or } from './or';
+export { DataBuilderFormulaPlain as Plain } from './plain';
+export { DataBuilderFormulaRecord as Record } from './record';
+export { DataBuilderFormulaTpl as Tpl } from './tpl';
+export { DataBuilderFormulaVar as Var } from './var';
+export { DataSchemaRef } from './dataSchemaRef';

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

@@ -0,0 +1 @@
+export {};

package/dist/dts/data-builder/formulas/iterate.d.ts

@@ -0,0 +1,19 @@
+import { DataBuilderFormulaBase, ResolveFormulaParams } from './base';
+export interface IterateArguments {
+    source: any;
+    item?: any;
+}
+export declare class DataBuilderFormulaIterate extends DataBuilderFormulaBase {
+    args: IterateArguments;
+    source: any;
+    item: any;
+    constructor(args: IterateArguments);
+    getValue(variables: any): never[] | undefined;
+    resolveValue(params: ResolveFormulaParams): Promise<any>;
+    getSchema(variablesSchema: any): {
+        type: string;
+        items: any;
+    };
+    getVariableLocators(): string[];
+    transformVars(transformations: any): any;
+}

package/dist/dts/data-builder/formulas/iterate.test.d.ts

@@ -0,0 +1 @@
+export {};