@membranehq/sdk 0.2.1 → 0.3.0

package/dist/bundle.js

@@ -9770,14 +9770,18 @@
 	const numberType = ZodNumber.create;
 	const booleanType = ZodBoolean.create;
 	const anyType = ZodAny.create;
+	const unknownType = ZodUnknown.create;
 	ZodNever.create;
 	const arrayType = ZodArray.create;
 	const objectType = ZodObject.create;
-	ZodUnion.create;
+	const unionType = ZodUnion.create;
 	ZodIntersection.create;
 	ZodTuple.create;
 	const recordType = ZodRecord.create;
+	const lazyType = ZodLazy.create;
+	const literalType = ZodLiteral.create;
 	const enumType = ZodEnum.create;
+	const nativeEnumType = ZodNativeEnum.create;
 	ZodPromise.create;
 	ZodOptional.create;
 	ZodNullable.create;
@@ -10808,7 +10812,7 @@
 	                });
 	            }
 	            else {
-	                throw Error('Integration.app container element not found. Was it manually removed?');
+	                throw Error('Membrane container element not found. Was it manually removed?');
 	            }
 	        }
 	        if (document.readyState === 'complete' || document.readyState === 'interactive') {
@@ -11234,6 +11238,15 @@
 	    }
 	}
 
+	var ErrorDoc;
+	(function (ErrorDoc) {
+	    ErrorDoc["AuthenticationTokenErrors"] = "authentication-token-errors";
+	    ErrorDoc["DataSourceNoCollectionSelected"] = "data-source-no-collection-selected";
+	    ErrorDoc["FlowInstanceSetupFailed"] = "flow-instance-setup-failed";
+	    ErrorDoc["FlowInstanceSetupTimeout"] = "flow-instance-setup-timeout";
+	    ErrorDoc["WebhookCannotFindUser"] = "webhook-cannot-find-user";
+	})(ErrorDoc || (ErrorDoc = {}));
+
 	var LogRecordType;
 	(function (LogRecordType) {
 	    LogRecordType["MSG"] = "message";
@@ -11244,15 +11257,6 @@
 	    LogRecordType["API"] = "api-request";
 	})(LogRecordType || (LogRecordType = {}));
 
-	var ErrorDoc;
-	(function (ErrorDoc) {
-	    ErrorDoc["AuthenticationTokenErrors"] = "authentication-token-errors";
-	    ErrorDoc["DataSourceNoCollectionSelected"] = "data-source-no-collection-selected";
-	    ErrorDoc["FlowInstanceSetupFailed"] = "flow-instance-setup-failed";
-	    ErrorDoc["FlowInstanceSetupTimeout"] = "flow-instance-setup-timeout";
-	    ErrorDoc["WebhookCannotFindUser"] = "webhook-cannot-find-user";
-	})(ErrorDoc || (ErrorDoc = {}));
-
 	var ErrorType;
 	(function (ErrorType) {
 	    ErrorType["BAD_REQUEST"] = "bad_request";
@@ -11286,6 +11290,16 @@
 	(function (ConcurrencyErrorKey) {
 	    ConcurrencyErrorKey["LOCK_TIMEOUT"] = "lock_timeout";
 	})(ConcurrencyErrorKey || (ConcurrencyErrorKey = {}));
+	const ErrorDataSchema = objectType({
+	    type: nativeEnumType(ErrorType).optional(),
+	    key: stringType().optional(),
+	    message: stringType(),
+	    data: anyType().optional(),
+	    doc: nativeEnumType(ErrorDoc).optional(),
+	    stack: anyType().optional(),
+	    causedByError: lazyType(() => ErrorDataSchema).optional(),
+	    logs: arrayType(anyType()).optional(),
+	});
 	class ErrorData {
 	    constructor(arg) {
 	        if (arg instanceof Error) {
@@ -12194,6 +12208,41 @@
 	    DataLocatorStepType["ARRAY_ITEM"] = "array_item";
 	})(DataLocatorStepType || (DataLocatorStepType = {}));
 
+	const DataSchemaSchema = lazyType(() => objectType({
+	    title: stringType().optional(),
+	    description: stringType().optional(),
+	    type: unionType([stringType(), arrayType(stringType())]).optional(),
+	    format: stringType().optional(),
+	    properties: recordType(DataSchemaSchema).optional(),
+	    items: DataSchemaSchema.optional(),
+	    additionalProperties: unionType([booleanType(), DataSchemaSchema]).optional(),
+	    enum: arrayType(stringType()).optional(),
+	    referenceRecords: arrayType(anyType()).optional(),
+	    referenceCollection: objectType({
+	        key: anyType(),
+	        parameters: recordType(anyType()).optional(),
+	    })
+	        .optional(),
+	    referenceUdm: stringType().optional(),
+	    default: anyType().optional(),
+	    allowCustom: booleanType().optional(),
+	    $ref: stringType().optional(),
+	    required: arrayType(stringType()).optional(),
+	    minLength: numberType().optional(),
+	    maxLength: numberType().optional(),
+	    minimum: numberType().optional(),
+	    maximum: numberType().optional(),
+	    maxItems: numberType().optional(),
+	    readOnly: booleanType().optional(),
+	    writeOnly: booleanType().optional(),
+	    examples: arrayType(anyType()).optional(),
+	    anyOf: arrayType(DataSchemaSchema).optional(),
+	    isImplied: booleanType().optional(),
+	    isSensitive: booleanType().optional(),
+	    referenceCollectionPath: stringType().optional(),
+	    referenceCollectionUri: stringType().optional(),
+	}));
+
 	var ConnectorMethodImplementationType;
 	(function (ConnectorMethodImplementationType) {
 	    ConnectorMethodImplementationType["mapping"] = "mapping";
@@ -12483,7 +12532,7 @@
 	    [UDM.TIMEOFF_REQUESTS]: udm$1,
 	});
 
-	const DataLocationMethodImplementationTypes = [
+	[
 	    ConnectorMethodImplementationType.operationMapping,
 	    ConnectorMethodImplementationType.restApiMapping,
 	    ConnectorMethodImplementationType.graphqlApiMapping,
@@ -12593,23 +12642,70 @@
 	    ],
 	});
 
-	({
-	    supportedImplementationTypes: [ConnectorMethodImplementationType.mapping, ...DataLocationMethodImplementationTypes],
+	const ApiRequestSpecSchema = objectType({
+	    path: unknownType(),
+	    method: unknownType(),
 	});
-
-	({
-	    supportedImplementationTypes: [ConnectorMethodImplementationType.javascript],
+	const DataCollectionMethodSpecSchema = objectType({
+	    apiRequests: arrayType(ApiRequestSpecSchema).optional(),
+	});
+	const DataCollectionListSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    filterFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionSearchSpecSchema = DataCollectionMethodSpecSchema.extend({});
+	const DataCollectionMatchSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    fields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionFindByIdSpecSchema = DataCollectionMethodSpecSchema.extend({});
+	const DataCollectionCreateSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    fields: arrayType(stringType()).optional(),
+	    requiredFields: arrayType(stringType()).optional(),
+	    excludedFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionUpdateSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    fields: arrayType(stringType()).optional(),
+	    excludedFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionDeleteSpecSchema = DataCollectionMethodSpecSchema.extend({});
+	const DataCollectionFindSpecSchema = DataCollectionMethodSpecSchema.extend({
+	    queryFields: arrayType(stringType()).optional(),
+	});
+	const DataCollectionEventTypeSpecSchema = objectType({
+	    type: enumType(['push', 'pull']),
+	    isFullScan: booleanType().optional(),
+	    isIdOnly: booleanType().optional(),
+	});
+	const DataCollectionEventsSpecSchema = objectType({
+	    created: DataCollectionEventTypeSpecSchema.optional(),
+	    updated: DataCollectionEventTypeSpecSchema.optional(),
+	    deleted: DataCollectionEventTypeSpecSchema.optional(),
+	    all: DataCollectionEventTypeSpecSchema.optional(),
+	})
+	    .catchall(DataCollectionEventTypeSpecSchema);
+	const DataCollectionUdmSpecSchema = objectType({
+	    fields: arrayType(stringType()).optional(),
+	    extract: recordType(anyType()).optional(),
+	    parse: recordType(anyType()).optional(),
+	});
+	const DataCollectionUdmsSpecSchema = recordType(DataCollectionUdmSpecSchema);
+	objectType({
+	    type: literalType('collection'),
+	    key: stringType().optional(),
+	    name: stringType(),
+	    parametersSchema: DataSchemaSchema.optional(),
+	    fieldsSchema: DataSchemaSchema.optional(),
+	    list: DataCollectionListSpecSchema.optional(),
+	    search: DataCollectionSearchSpecSchema.optional(),
+	    match: DataCollectionMatchSpecSchema.optional(),
+	    findById: DataCollectionFindByIdSpecSchema.optional(),
+	    create: DataCollectionCreateSpecSchema.optional(),
+	    update: DataCollectionUpdateSpecSchema.optional(),
+	    delete: DataCollectionDeleteSpecSchema.optional(),
+	    events: DataCollectionEventsSpecSchema.optional(),
+	    customFields: booleanType().optional(),
+	    udm: DataCollectionUdmsSpecSchema.optional(),
+	    find: DataCollectionFindSpecSchema.optional(),
 	});
-
-	var DataLocationType;
-	(function (DataLocationType) {
-	    DataLocationType["directory"] = "directory";
-	    DataLocationType["collection"] = "collection";
-	})(DataLocationType || (DataLocationType = {}));
-	var DataDirectoryOperation;
-	(function (DataDirectoryOperation) {
-	    DataDirectoryOperation["list"] = "list";
-	})(DataDirectoryOperation || (DataDirectoryOperation = {}));
 
 	var urlJoin$1 = {exports: {}};
 
@@ -24880,6 +24976,49 @@
 	    FlowNodeRunStatus["FAILED"] = "failed";
 	    FlowNodeRunStatus["SKIPPED"] = "skipped";
 	})(FlowNodeRunStatus || (FlowNodeRunStatus = {}));
+	const UpstreamFlowNodeRunSchema = objectType({
+	    nodeKey: stringType(),
+	    runId: stringType(),
+	    outputId: stringType(),
+	});
+	const DownstreamFlowNodeRunSchema = objectType({
+	    runId: stringType(),
+	    nodeKey: stringType(),
+	});
+	const FlowNodeRunParametersSchema = objectType({
+	    id: stringType(),
+	    upstreamRuns: arrayType(UpstreamFlowNodeRunSchema),
+	    input: anyType(),
+	});
+	const FlowNodeRunOutputSchema = objectType({
+	    id: stringType(),
+	    data: stringType(),
+	    downstreamRuns: arrayType(DownstreamFlowNodeRunSchema),
+	});
+	const FlowNodeRunResultSchema = objectType({
+	    status: nativeEnumType(FlowNodeRunStatus),
+	    logs: arrayType(anyType()),
+	    outputs: arrayType(FlowNodeRunOutputSchema),
+	    errors: arrayType(ErrorDataSchema),
+	});
+	FlowNodeRunParametersSchema.merge(FlowNodeRunResultSchema);
+	objectType({
+	    id: stringType(),
+	    data: stringType(),
+	});
+	const FlowNodeRunOutputMetadataSchema = objectType({
+	    id: stringType(),
+	    downstreamRuns: arrayType(DownstreamFlowNodeRunSchema),
+	});
+	objectType({
+	    id: stringType(),
+	    upstreamRuns: arrayType(UpstreamFlowNodeRunSchema),
+	    input: anyType(),
+	    status: nativeEnumType(FlowNodeRunStatus),
+	    logs: arrayType(anyType()),
+	    outputs: arrayType(FlowNodeRunOutputMetadataSchema),
+	    errors: arrayType(ErrorDataSchema),
+	});
 
 	class FlowRunsAccessor {
 	    constructor(client) {
@@ -25507,9 +25646,6 @@
 	    dataCollection(key, parameters) {
 	        return new ConnectionDataCollectionAccessor(this.client, this, key, parameters);
 	    }
-	    dataDirectory(key, parameters) {
-	        return new ConnectionDataDirectoryAccessor(this.client, this, key, parameters);
-	    }
 	    async reconnect({ parameters, authOptionKey, connectorParameters, } = {}) {
 	        const connection = await this.get();
 	        const connectorSpec = await this.client.get(`/integrations/${connection.integrationId}/connector-spec`);
@@ -25553,17 +25689,6 @@
 	        return this.client.post(this.connectionAccessor.getPath(`operations/${this.key}/run`), request);
 	    }
 	}
-	class ConnectionDataDirectoryAccessor {
-	    constructor(client, connectionAccessor, key, parameters) {
-	        this.client = client;
-	        this.connectionAccessor = connectionAccessor;
-	        this.key = key;
-	        this.parameters = parameters;
-	    }
-	    async list(request) {
-	        return this.client.post(this.connectionAccessor.getPath(`data/${this.key}/list`, this.parameters), request);
-	    }
-	}
 	class ConnectionDataCollectionAccessor {
 	    constructor(client, connectionAccessor, key, parameters) {
 	        this.client = client;
@@ -25838,12 +25963,6 @@
 	    async getDataCollection(key) {
 	        return this.client.get(this.getPath(`data/${key}`));
 	    }
-	    async getDataLocations() {
-	        return this.client.get(this.getPath('data'));
-	    }
-	    async getDataLocation(key) {
-	        return this.client.get(this.getPath(`data/${key}`));
-	    }
 	}
 
 	var ScenarioTemplateCategory;