@membranehq/sdk 0.5.0 → 0.5.1

package/dist/bundle.js

@@ -9791,6 +9791,60 @@
 	        ...processCreateParams(params),
 	    });
 	};
+	class ZodRecord extends ZodType {
+	    get keySchema() {
+	        return this._def.keyType;
+	    }
+	    get valueSchema() {
+	        return this._def.valueType;
+	    }
+	    _parse(input) {
+	        const { status, ctx } = this._processInputParams(input);
+	        if (ctx.parsedType !== ZodParsedType.object) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.object,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        const pairs = [];
+	        const keyType = this._def.keyType;
+	        const valueType = this._def.valueType;
+	        for (const key in ctx.data) {
+	            pairs.push({
+	                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+	                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
+	                alwaysSet: key in ctx.data,
+	            });
+	        }
+	        if (ctx.common.async) {
+	            return ParseStatus.mergeObjectAsync(status, pairs);
+	        }
+	        else {
+	            return ParseStatus.mergeObjectSync(status, pairs);
+	        }
+	    }
+	    get element() {
+	        return this._def.valueType;
+	    }
+	    static create(first, second, third) {
+	        if (second instanceof ZodType) {
+	            return new ZodRecord({
+	                keyType: first,
+	                valueType: second,
+	                typeName: ZodFirstPartyTypeKind.ZodRecord,
+	                ...processCreateParams(third),
+	            });
+	        }
+	        return new ZodRecord({
+	            keyType: ZodString.create(),
+	            valueType: first,
+	            typeName: ZodFirstPartyTypeKind.ZodRecord,
+	            ...processCreateParams(second),
+	        });
+	    }
+	}
 	class ZodMap extends ZodType {
 	    get keySchema() {
 	        return this._def.keyType;
@@ -10662,6 +10716,7 @@
 	    ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
 	})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
 	const stringType = ZodString.create;
+	const numberType = ZodNumber.create;
 	const booleanType = ZodBoolean.create;
 	const anyType = ZodAny.create;
 	ZodUnknown.create;
@@ -10671,6 +10726,7 @@
 	ZodUnion.create;
 	ZodIntersection.create;
 	ZodTuple.create;
+	const recordType = ZodRecord.create;
 	const functionType = ZodFunction.create;
 	const lazyType = ZodLazy.create;
 	ZodEnum.create;
@@ -11321,6 +11377,13 @@
 	    }
 	}
 
+	var FlowRunNodeState;
+	(function (FlowRunNodeState) {
+	    FlowRunNodeState["RUNNING"] = "running";
+	    FlowRunNodeState["COMPLETED"] = "completed";
+	    FlowRunNodeState["STOPPED"] = "stopped";
+	    FlowRunNodeState["FAILED"] = "failed";
+	})(FlowRunNodeState || (FlowRunNodeState = {}));
 	var FlowRunState;
 	(function (FlowRunState) {
 	    FlowRunState["QUEUED"] = "queued";
@@ -11337,6 +11400,83 @@
 	    FlowRunLaunchedByTrigger["DataSourceTrigger"] = "data-source-trigger";
 	    FlowRunLaunchedByTrigger["ExternalEvent"] = "external-event";
 	})(FlowRunLaunchedByTrigger || (FlowRunLaunchedByTrigger = {}));
+	const FlowRunLaunchedBy = objectType({
+	    type: nativeEnumType(FlowRunLaunchedByTrigger),
+	    ids: arrayType(stringType()).optional(),
+	});
+	const FlowRunNode = objectType({
+	    state: nativeEnumType(FlowRunNodeState),
+	    runs: numberType().optional(),
+	    erroredRuns: numberType().optional(),
+	    outputs: numberType().optional(),
+	});
+	objectType({
+	    id: stringType(),
+	    name: stringType().optional(),
+	    flowInstanceId: stringType(),
+	    universalFlowId: stringType().optional(),
+	    connectionId: stringType().optional(),
+	    integrationId: stringType().optional(),
+	    startNodeKey: stringType(),
+	    userId: stringType(),
+	    input: anyType().optional(),
+	    state: nativeEnumType(FlowRunState),
+	    startTime: stringType(),
+	    endTime: stringType().optional(),
+	    errors: arrayType(ErrorDataSchema).optional(),
+	    nodes: recordType(FlowRunNode).optional(),
+	    launchedBy: FlowRunLaunchedBy.optional(),
+	});
+
+	var FlowNodeRunStatus;
+	(function (FlowNodeRunStatus) {
+	    FlowNodeRunStatus["COMPLETED"] = "completed";
+	    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) {
@@ -11432,6 +11572,7 @@
 	    WorkspaceElementType["DataLinkTableInstance"] = "data-link-table-instance";
 	    WorkspaceElementType["AppEventType"] = "app-event-type";
 	    WorkspaceElementType["AppEventSubscription"] = "app-event-subscription";
+	    WorkspaceElementType["AppEventLogRecord"] = "app-event-log-record";
 	    WorkspaceElementType["AppDataSchema"] = "app-data-schema";
 	    WorkspaceElementType["AppDataSchemaInstance"] = "app-data-schema-instance";
 	    WorkspaceElementType["ExternalEventSubscription"] = "external-event-subscription";
@@ -11469,9 +11610,16 @@
 	    name: stringType(),
 	});
 	BaseWorkspaceElement.extend({
-	    key: stringType(),
+	    key: stringType().optional(),
+	    uuid: stringType().optional(),
+	    description: stringType().optional(),
 	    state: nativeEnumType(WorkspaceElementState).optional(),
 	    errors: arrayType(ErrorDataSchema).optional(),
+	    revision: stringType().optional(),
+	    isDeactivated: booleanType().optional(),
+	    createdAt: stringType().optional(),
+	    updatedAt: stringType().optional(),
+	    archivedAt: stringType().optional(),
 	});
 
 	const MAX_POLLING_ERRORS = 10;