import { s } from "bknd/utils";
export declare const TASKS: {
    readonly fetch: {
        readonly cls: typeof import("../flows").FetchTask;
    };
    readonly log: {
        readonly cls: typeof import("../flows").LogTask;
    };
    readonly render: {
        readonly cls: typeof import("../flows").RenderTask;
    };
    readonly subflow: {
        readonly cls: typeof import("../flows").SubFlowTask;
    };
};
export declare const TRIGGERS: {
    readonly manual: {
        readonly cls: typeof import("../flows").Trigger;
    };
    readonly event: {
        readonly cls: typeof import("../flows").EventTrigger;
    };
    readonly http: {
        readonly cls: typeof import("../flows").HttpTrigger;
    };
};
declare const taskSchema: s.Schema<s.IUnionOptions, {
    type: "log" | "fetch" | "render" | "subflow";
    params: {
        method?: string | undefined;
        headers?: {
            key: string;
            value: string;
        }[] | undefined;
        body?: string | undefined;
        normal?: number | undefined;
        url: string;
    } | {
        delay: number;
    } | {
        render: string;
    } | {
        flow?: any;
        input?: any;
        loop?: boolean | undefined;
    };
}, never> & s.Merge<s.IUnionOptions & {
    anyOf: s.ObjectSchema<{
        readonly type: s.Schema<s.ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & s.Merge<s.ILiteralOptions & {
            const: "log" | "fetch" | "render" | "subflow";
        }>;
        readonly params: s.ObjectSchema<{
            readonly url: s.StringSchema<{
                readonly pattern: "^(http|https)://";
            }> & {
                readonly pattern: "^(http|https)://";
            };
            readonly method: {
                readonly default: "GET";
                readonly enum: string[];
            } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
            readonly headers: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                $defs?: Record<string, s.Schema> | undefined;
                contains?: s.Schema | undefined;
                minContains?: number | undefined;
                maxContains?: number | undefined;
                prefixItems?: s.Schema[] | undefined;
                uniqueItems?: boolean | undefined;
                maxItems?: number | undefined;
                minItems?: number | undefined;
                readonly items?: s.ObjectSchema<{
                    readonly key: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                    readonly value: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>> | undefined;
            } & s.Schema<s.ISchemaOptions, {
                key: string;
                value: string;
            }[] | undefined, {
                key: string;
                value: string;
            }[] | undefined>;
            readonly body: {
                default?: any;
                maxLength?: number | undefined;
                minLength?: number | undefined;
                pattern?: (string | RegExp) | undefined;
                format?: string | undefined;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
            } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
            readonly normal: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
                multipleOf?: number | undefined;
                maximum?: number | undefined;
                exclusiveMaximum?: number | undefined;
                minimum?: number | undefined;
                exclusiveMinimum?: number | undefined;
            } & s.Schema<s.ISchemaOptions, number | undefined, number | undefined>;
        }, s.Merge<s.IObjectOptions & {
            additionalProperties: false;
        }>> | s.ObjectSchema<{
            readonly delay: s.Schema<{
                readonly default: 10;
            }, number, number> & {
                readonly default: 10;
            };
        }, s.Merge<s.IObjectOptions & {
            additionalProperties: false;
        }>> | s.ObjectSchema<{
            readonly render: s.StringSchema<s.IStringOptions> & s.IStringOptions;
        }, s.Merge<s.IObjectOptions & {
            additionalProperties: false;
        }>> | s.ObjectSchema<{
            readonly flow: s.Schema<s.IAnyOptions, any, any> & s.IAnyOptions;
            readonly input: {
                [x: string]: any;
                [x: number]: any;
            } & s.Schema<s.ISchemaOptions, any, any>;
            readonly loop: {
                default?: any;
                enum?: (readonly any[] | any[]) | undefined;
                const?: any;
            } & s.Schema<s.ISchemaOptions, boolean | undefined, boolean | undefined>;
        }, s.Merge<s.IObjectOptions & {
            additionalProperties: false;
        }>>;
    }, s.Merge<{
        readonly title: string;
    } & {
        additionalProperties: false;
    }>>[];
}>;
export type TAppFlowTaskSchema = s.Static<typeof taskSchema>;
declare const triggerSchema: s.Schema<s.IUnionOptions, {
    config?: {
        mode: "sync" | "async";
    } | {
        event: string;
        mode: "sync" | "async";
    } | {
        path: string;
        mode: "sync" | "async";
        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
        response_type: "html" | "json" | "text";
    } | undefined;
    type: "manual" | "event" | "http";
}, never> & s.Merge<s.IUnionOptions & {
    anyOf: s.ObjectSchema<{
        readonly type: s.Schema<s.ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & s.Merge<s.ILiteralOptions & {
            const: "manual" | "event" | "http";
        }>;
        readonly config: ({
            properties: {
                readonly mode: s.StringSchema<{
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                }> & {
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                };
            };
            required: string[] | undefined;
            strict: () => s.ObjectSchema<{
                readonly mode: s.StringSchema<{
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                }> & {
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                };
            }, s.Merge<s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }> & {
                additionalProperties: false;
            }>>;
            partial: () => s.ObjectSchema<{
                readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
            }, s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }>>;
        } & s.Schema<s.ISchemaOptions, {
            mode: "sync" | "async";
        } | undefined, {
            mode: "sync" | "async";
        } | undefined>) | ({
            properties: {
                readonly mode: s.StringSchema<{
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                }> & {
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                };
                readonly event: s.StringSchema<s.IStringOptions> & s.IStringOptions;
            };
            required: string[] | undefined;
            strict: () => s.ObjectSchema<{
                readonly mode: s.StringSchema<{
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                }> & {
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                };
                readonly event: s.StringSchema<s.IStringOptions> & s.IStringOptions;
            }, s.Merge<s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }> & {
                additionalProperties: false;
            }>>;
            partial: () => s.ObjectSchema<{
                readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                readonly event: s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
            }, s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }>>;
        } & s.Schema<s.ISchemaOptions, {
            event: string;
            mode: "sync" | "async";
        } | undefined, {
            event: string;
            mode: "sync" | "async";
        } | undefined>) | ({
            properties: {
                readonly mode: s.StringSchema<{
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                }> & {
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                };
                readonly path: s.StringSchema<{
                    readonly pattern: "^/.*$";
                }> & {
                    readonly pattern: "^/.*$";
                };
                readonly method: s.StringSchema<{
                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                    readonly default: "GET";
                }> & {
                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                    readonly default: "GET";
                };
                readonly response_type: s.StringSchema<{
                    readonly enum: readonly ["json", "text", "html"];
                    readonly default: "json";
                }> & {
                    readonly enum: readonly ["json", "text", "html"];
                    readonly default: "json";
                };
            };
            required: string[] | undefined;
            strict: () => s.ObjectSchema<{
                readonly mode: s.StringSchema<{
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                }> & {
                    readonly enum: readonly ["sync", "async"];
                    readonly default: "async";
                };
                readonly path: s.StringSchema<{
                    readonly pattern: "^/.*$";
                }> & {
                    readonly pattern: "^/.*$";
                };
                readonly method: s.StringSchema<{
                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                    readonly default: "GET";
                }> & {
                    readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                    readonly default: "GET";
                };
                readonly response_type: s.StringSchema<{
                    readonly enum: readonly ["json", "text", "html"];
                    readonly default: "json";
                }> & {
                    readonly enum: readonly ["json", "text", "html"];
                    readonly default: "json";
                };
            }, s.Merge<s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }> & {
                additionalProperties: false;
            }>>;
            partial: () => s.ObjectSchema<{
                readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                readonly path: s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                readonly method: s.Schema<s.ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                readonly response_type: s.Schema<s.ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
            }, s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }>>;
        } & s.Schema<s.ISchemaOptions, {
            path: string;
            mode: "sync" | "async";
            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
            response_type: "html" | "json" | "text";
        } | undefined, {
            path: string;
            mode: "sync" | "async";
            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
            response_type: "html" | "json" | "text";
        } | undefined>);
    }, s.Merge<{
        readonly title: string;
    } & {
        additionalProperties: false;
    }>>[];
}>;
export type TAppFlowTriggerSchema = s.Static<typeof triggerSchema>;
export declare const flowSchema: s.ObjectSchema<{
    readonly trigger: s.Schema<s.IUnionOptions, {
        config?: {
            mode: "sync" | "async";
        } | {
            event: string;
            mode: "sync" | "async";
        } | {
            path: string;
            mode: "sync" | "async";
            method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
            response_type: "html" | "json" | "text";
        } | undefined;
        type: "manual" | "event" | "http";
    }, never> & s.Merge<s.IUnionOptions & {
        anyOf: s.ObjectSchema<{
            readonly type: s.Schema<s.ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & s.Merge<s.ILiteralOptions & {
                const: "manual" | "event" | "http";
            }>;
            readonly config: ({
                properties: {
                    readonly mode: s.StringSchema<{
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    }> & {
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    };
                };
                required: string[] | undefined;
                strict: () => s.ObjectSchema<{
                    readonly mode: s.StringSchema<{
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    }> & {
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    };
                }, s.Merge<s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }> & {
                    additionalProperties: false;
                }>>;
                partial: () => s.ObjectSchema<{
                    readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & s.Schema<s.ISchemaOptions, {
                mode: "sync" | "async";
            } | undefined, {
                mode: "sync" | "async";
            } | undefined>) | ({
                properties: {
                    readonly mode: s.StringSchema<{
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    }> & {
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    };
                    readonly event: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                };
                required: string[] | undefined;
                strict: () => s.ObjectSchema<{
                    readonly mode: s.StringSchema<{
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    }> & {
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    };
                    readonly event: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                }, s.Merge<s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }> & {
                    additionalProperties: false;
                }>>;
                partial: () => s.ObjectSchema<{
                    readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                    readonly event: s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & s.Schema<s.ISchemaOptions, {
                event: string;
                mode: "sync" | "async";
            } | undefined, {
                event: string;
                mode: "sync" | "async";
            } | undefined>) | ({
                properties: {
                    readonly mode: s.StringSchema<{
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    }> & {
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    };
                    readonly path: s.StringSchema<{
                        readonly pattern: "^/.*$";
                    }> & {
                        readonly pattern: "^/.*$";
                    };
                    readonly method: s.StringSchema<{
                        readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                        readonly default: "GET";
                    }> & {
                        readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                        readonly default: "GET";
                    };
                    readonly response_type: s.StringSchema<{
                        readonly enum: readonly ["json", "text", "html"];
                        readonly default: "json";
                    }> & {
                        readonly enum: readonly ["json", "text", "html"];
                        readonly default: "json";
                    };
                };
                required: string[] | undefined;
                strict: () => s.ObjectSchema<{
                    readonly mode: s.StringSchema<{
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    }> & {
                        readonly enum: readonly ["sync", "async"];
                        readonly default: "async";
                    };
                    readonly path: s.StringSchema<{
                        readonly pattern: "^/.*$";
                    }> & {
                        readonly pattern: "^/.*$";
                    };
                    readonly method: s.StringSchema<{
                        readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                        readonly default: "GET";
                    }> & {
                        readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                        readonly default: "GET";
                    };
                    readonly response_type: s.StringSchema<{
                        readonly enum: readonly ["json", "text", "html"];
                        readonly default: "json";
                    }> & {
                        readonly enum: readonly ["json", "text", "html"];
                        readonly default: "json";
                    };
                }, s.Merge<s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }> & {
                    additionalProperties: false;
                }>>;
                partial: () => s.ObjectSchema<{
                    readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                    readonly path: s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                    readonly method: s.Schema<s.ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                    readonly response_type: s.Schema<s.ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>>;
            } & s.Schema<s.ISchemaOptions, {
                path: string;
                mode: "sync" | "async";
                method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                response_type: "html" | "json" | "text";
            } | undefined, {
                path: string;
                mode: "sync" | "async";
                method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                response_type: "html" | "json" | "text";
            } | undefined>);
        }, s.Merge<{
            readonly title: string;
        } & {
            additionalProperties: false;
        }>>[];
    }>;
    readonly tasks: {
        additionalProperties: s.Schema<s.IUnionOptions, {
            type: "log" | "fetch" | "render" | "subflow";
            params: {
                method?: string | undefined;
                headers?: {
                    key: string;
                    value: string;
                }[] | undefined;
                body?: string | undefined;
                normal?: number | undefined;
                url: string;
            } | {
                delay: number;
            } | {
                render: string;
            } | {
                flow?: any;
                input?: any;
                loop?: boolean | undefined;
            };
        }, never> & s.Merge<s.IUnionOptions & {
            anyOf: s.ObjectSchema<{
                readonly type: s.Schema<s.ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & s.Merge<s.ILiteralOptions & {
                    const: "log" | "fetch" | "render" | "subflow";
                }>;
                readonly params: s.ObjectSchema<{
                    readonly url: s.StringSchema<{
                        readonly pattern: "^(http|https)://";
                    }> & {
                        readonly pattern: "^(http|https)://";
                    };
                    readonly method: {
                        readonly default: "GET";
                        readonly enum: string[];
                    } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                    readonly headers: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                        $defs?: Record<string, s.Schema> | undefined;
                        contains?: s.Schema | undefined;
                        minContains?: number | undefined;
                        maxContains?: number | undefined;
                        prefixItems?: s.Schema[] | undefined;
                        uniqueItems?: boolean | undefined;
                        maxItems?: number | undefined;
                        minItems?: number | undefined;
                        readonly items?: s.ObjectSchema<{
                            readonly key: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                            readonly value: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                        }, s.Merge<s.IObjectOptions & {
                            additionalProperties: false;
                        }>> | undefined;
                    } & s.Schema<s.ISchemaOptions, {
                        key: string;
                        value: string;
                    }[] | undefined, {
                        key: string;
                        value: string;
                    }[] | undefined>;
                    readonly body: {
                        default?: any;
                        maxLength?: number | undefined;
                        minLength?: number | undefined;
                        pattern?: (string | RegExp) | undefined;
                        format?: string | undefined;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                    readonly normal: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                        multipleOf?: number | undefined;
                        maximum?: number | undefined;
                        exclusiveMaximum?: number | undefined;
                        minimum?: number | undefined;
                        exclusiveMinimum?: number | undefined;
                    } & s.Schema<s.ISchemaOptions, number | undefined, number | undefined>;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>> | s.ObjectSchema<{
                    readonly delay: s.Schema<{
                        readonly default: 10;
                    }, number, number> & {
                        readonly default: 10;
                    };
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>> | s.ObjectSchema<{
                    readonly render: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>> | s.ObjectSchema<{
                    readonly flow: s.Schema<s.IAnyOptions, any, any> & s.IAnyOptions;
                    readonly input: {
                        [x: string]: any;
                        [x: number]: any;
                    } & s.Schema<s.ISchemaOptions, any, any>;
                    readonly loop: {
                        default?: any;
                        enum?: (readonly any[] | any[]) | undefined;
                        const?: any;
                    } & s.Schema<s.ISchemaOptions, boolean | undefined, boolean | undefined>;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>>;
            }, s.Merge<{
                readonly title: string;
            } & {
                additionalProperties: false;
            }>>[];
        }>;
    } & s.Schema<s.ISchemaOptions, {
        [x: string]: {
            type: "log" | "fetch" | "render" | "subflow";
            params: {
                method?: string | undefined;
                headers?: {
                    key: string;
                    value: string;
                }[] | undefined;
                body?: string | undefined;
                normal?: number | undefined;
                url: string;
            } | {
                delay: number;
            } | {
                render: string;
            } | {
                flow?: any;
                input?: any;
                loop?: boolean | undefined;
            };
        };
    } | undefined, {
        [x: string]: never;
    } | undefined>;
    readonly connections: {
        additionalProperties: s.ObjectSchema<{
            readonly source: s.StringSchema<s.IStringOptions> & s.IStringOptions;
            readonly target: s.StringSchema<s.IStringOptions> & s.IStringOptions;
            readonly config: s.ObjectSchema<{
                readonly condition: s.Schema<s.ISchemaOptions, {
                    type: "success";
                } | {
                    type: "error";
                } | {
                    value: string;
                    type: "matches";
                    path: string;
                } | undefined, {
                    type: "error";
                } | {
                    value: string;
                    type: "matches";
                    path: string;
                } | {
                    type: "success";
                } | undefined>;
                readonly max_retries: s.Schema<s.ISchemaOptions, number | undefined, number | undefined>;
            }, s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }>>;
        }, s.Merge<s.IObjectOptions & {
            additionalProperties: false;
        }>>;
    } & s.Schema<s.ISchemaOptions, {
        [x: string]: {
            config: {
                condition?: {
                    type: "success";
                } | {
                    type: "error";
                } | {
                    value: string;
                    type: "matches";
                    path: string;
                } | undefined;
                max_retries?: number | undefined;
            };
            target: string;
            source: string;
        };
    } | undefined, {
        [x: string]: {
            config: {
                condition?: {
                    type: "error";
                } | {
                    value: string;
                    type: "matches";
                    path: string;
                } | {
                    type: "success";
                } | undefined;
                max_retries?: number | undefined;
            };
            target: string;
            source: string;
        };
    } | undefined>;
    readonly start_task: {
        default?: any;
        maxLength?: number | undefined;
        minLength?: number | undefined;
        pattern?: (string | RegExp) | undefined;
        format?: string | undefined;
        enum?: (readonly any[] | any[]) | undefined;
        const?: any;
    } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
    readonly responding_task: {
        default?: any;
        maxLength?: number | undefined;
        minLength?: number | undefined;
        pattern?: (string | RegExp) | undefined;
        format?: string | undefined;
        enum?: (readonly any[] | any[]) | undefined;
        const?: any;
    } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
}, s.Merge<s.IObjectOptions & {
    additionalProperties: false;
}>>;
export type TAppFlowSchema = s.Static<typeof flowSchema>;
export declare const flowsConfigSchema: s.ObjectSchema<{
    readonly basepath: s.StringSchema<{
        readonly default: "/api/flows";
    }> & {
        readonly default: "/api/flows";
    };
    readonly flows: s.RecordSchema<s.ObjectSchema<{
        readonly trigger: s.Schema<s.IUnionOptions, {
            config?: {
                mode: "sync" | "async";
            } | {
                event: string;
                mode: "sync" | "async";
            } | {
                path: string;
                mode: "sync" | "async";
                method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                response_type: "html" | "json" | "text";
            } | undefined;
            type: "manual" | "event" | "http";
        }, never> & s.Merge<s.IUnionOptions & {
            anyOf: s.ObjectSchema<{
                readonly type: s.Schema<s.ILiteralOptions, "manual" | "event" | "http", "manual" | "event" | "http"> & s.Merge<s.ILiteralOptions & {
                    const: "manual" | "event" | "http";
                }>;
                readonly config: ({
                    properties: {
                        readonly mode: s.StringSchema<{
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        }> & {
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        };
                    };
                    required: string[] | undefined;
                    strict: () => s.ObjectSchema<{
                        readonly mode: s.StringSchema<{
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        }> & {
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        };
                    }, s.Merge<s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }> & {
                        additionalProperties: false;
                    }>>;
                    partial: () => s.ObjectSchema<{
                        readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                    }, s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & s.Schema<s.ISchemaOptions, {
                    mode: "sync" | "async";
                } | undefined, {
                    mode: "sync" | "async";
                } | undefined>) | ({
                    properties: {
                        readonly mode: s.StringSchema<{
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        }> & {
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        };
                        readonly event: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                    };
                    required: string[] | undefined;
                    strict: () => s.ObjectSchema<{
                        readonly mode: s.StringSchema<{
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        }> & {
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        };
                        readonly event: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                    }, s.Merge<s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }> & {
                        additionalProperties: false;
                    }>>;
                    partial: () => s.ObjectSchema<{
                        readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                        readonly event: s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                    }, s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & s.Schema<s.ISchemaOptions, {
                    event: string;
                    mode: "sync" | "async";
                } | undefined, {
                    event: string;
                    mode: "sync" | "async";
                } | undefined>) | ({
                    properties: {
                        readonly mode: s.StringSchema<{
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        }> & {
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        };
                        readonly path: s.StringSchema<{
                            readonly pattern: "^/.*$";
                        }> & {
                            readonly pattern: "^/.*$";
                        };
                        readonly method: s.StringSchema<{
                            readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                            readonly default: "GET";
                        }> & {
                            readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                            readonly default: "GET";
                        };
                        readonly response_type: s.StringSchema<{
                            readonly enum: readonly ["json", "text", "html"];
                            readonly default: "json";
                        }> & {
                            readonly enum: readonly ["json", "text", "html"];
                            readonly default: "json";
                        };
                    };
                    required: string[] | undefined;
                    strict: () => s.ObjectSchema<{
                        readonly mode: s.StringSchema<{
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        }> & {
                            readonly enum: readonly ["sync", "async"];
                            readonly default: "async";
                        };
                        readonly path: s.StringSchema<{
                            readonly pattern: "^/.*$";
                        }> & {
                            readonly pattern: "^/.*$";
                        };
                        readonly method: s.StringSchema<{
                            readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                            readonly default: "GET";
                        }> & {
                            readonly enum: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
                            readonly default: "GET";
                        };
                        readonly response_type: s.StringSchema<{
                            readonly enum: readonly ["json", "text", "html"];
                            readonly default: "json";
                        }> & {
                            readonly enum: readonly ["json", "text", "html"];
                            readonly default: "json";
                        };
                    }, s.Merge<s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }> & {
                        additionalProperties: false;
                    }>>;
                    partial: () => s.ObjectSchema<{
                        readonly mode: s.Schema<s.ISchemaOptions, "sync" | "async" | undefined, "sync" | "async" | undefined>;
                        readonly path: s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                        readonly method: s.Schema<s.ISchemaOptions, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined, "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | undefined>;
                        readonly response_type: s.Schema<s.ISchemaOptions, "html" | "json" | "text" | undefined, "html" | "json" | "text" | undefined>;
                    }, s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                } & s.Schema<s.ISchemaOptions, {
                    path: string;
                    mode: "sync" | "async";
                    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                    response_type: "html" | "json" | "text";
                } | undefined, {
                    path: string;
                    mode: "sync" | "async";
                    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
                    response_type: "html" | "json" | "text";
                } | undefined>);
            }, s.Merge<{
                readonly title: string;
            } & {
                additionalProperties: false;
            }>>[];
        }>;
        readonly tasks: {
            additionalProperties: s.Schema<s.IUnionOptions, {
                type: "log" | "fetch" | "render" | "subflow";
                params: {
                    method?: string | undefined;
                    headers?: {
                        key: string;
                        value: string;
                    }[] | undefined;
                    body?: string | undefined;
                    normal?: number | undefined;
                    url: string;
                } | {
                    delay: number;
                } | {
                    render: string;
                } | {
                    flow?: any;
                    input?: any;
                    loop?: boolean | undefined;
                };
            }, never> & s.Merge<s.IUnionOptions & {
                anyOf: s.ObjectSchema<{
                    readonly type: s.Schema<s.ILiteralOptions, "log" | "fetch" | "render" | "subflow", "log" | "fetch" | "render" | "subflow"> & s.Merge<s.ILiteralOptions & {
                        const: "log" | "fetch" | "render" | "subflow";
                    }>;
                    readonly params: s.ObjectSchema<{
                        readonly url: s.StringSchema<{
                            readonly pattern: "^(http|https)://";
                        }> & {
                            readonly pattern: "^(http|https)://";
                        };
                        readonly method: {
                            readonly default: "GET";
                            readonly enum: string[];
                        } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                        readonly headers: {
                            default?: any;
                            enum?: (readonly any[] | any[]) | undefined;
                            const?: any;
                            $defs?: Record<string, s.Schema> | undefined;
                            contains?: s.Schema | undefined;
                            minContains?: number | undefined;
                            maxContains?: number | undefined;
                            prefixItems?: s.Schema[] | undefined;
                            uniqueItems?: boolean | undefined;
                            maxItems?: number | undefined;
                            minItems?: number | undefined;
                            readonly items?: s.ObjectSchema<{
                                readonly key: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                                readonly value: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                            }, s.Merge<s.IObjectOptions & {
                                additionalProperties: false;
                            }>> | undefined;
                        } & s.Schema<s.ISchemaOptions, {
                            key: string;
                            value: string;
                        }[] | undefined, {
                            key: string;
                            value: string;
                        }[] | undefined>;
                        readonly body: {
                            default?: any;
                            maxLength?: number | undefined;
                            minLength?: number | undefined;
                            pattern?: (string | RegExp) | undefined;
                            format?: string | undefined;
                            enum?: (readonly any[] | any[]) | undefined;
                            const?: any;
                        } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
                        readonly normal: {
                            default?: any;
                            enum?: (readonly any[] | any[]) | undefined;
                            const?: any;
                            multipleOf?: number | undefined;
                            maximum?: number | undefined;
                            exclusiveMaximum?: number | undefined;
                            minimum?: number | undefined;
                            exclusiveMinimum?: number | undefined;
                        } & s.Schema<s.ISchemaOptions, number | undefined, number | undefined>;
                    }, s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }>> | s.ObjectSchema<{
                        readonly delay: s.Schema<{
                            readonly default: 10;
                        }, number, number> & {
                            readonly default: 10;
                        };
                    }, s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }>> | s.ObjectSchema<{
                        readonly render: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                    }, s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }>> | s.ObjectSchema<{
                        readonly flow: s.Schema<s.IAnyOptions, any, any> & s.IAnyOptions;
                        readonly input: {
                            [x: string]: any;
                            [x: number]: any;
                        } & s.Schema<s.ISchemaOptions, any, any>;
                        readonly loop: {
                            default?: any;
                            enum?: (readonly any[] | any[]) | undefined;
                            const?: any;
                        } & s.Schema<s.ISchemaOptions, boolean | undefined, boolean | undefined>;
                    }, s.Merge<s.IObjectOptions & {
                        additionalProperties: false;
                    }>>;
                }, s.Merge<{
                    readonly title: string;
                } & {
                    additionalProperties: false;
                }>>[];
            }>;
        } & s.Schema<s.ISchemaOptions, {
            [x: string]: {
                type: "log" | "fetch" | "render" | "subflow";
                params: {
                    method?: string | undefined;
                    headers?: {
                        key: string;
                        value: string;
                    }[] | undefined;
                    body?: string | undefined;
                    normal?: number | undefined;
                    url: string;
                } | {
                    delay: number;
                } | {
                    render: string;
                } | {
                    flow?: any;
                    input?: any;
                    loop?: boolean | undefined;
                };
            };
        } | undefined, {
            [x: string]: never;
        } | undefined>;
        readonly connections: {
            additionalProperties: s.ObjectSchema<{
                readonly source: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                readonly target: s.StringSchema<s.IStringOptions> & s.IStringOptions;
                readonly config: s.ObjectSchema<{
                    readonly condition: s.Schema<s.ISchemaOptions, {
                        type: "success";
                    } | {
                        type: "error";
                    } | {
                        value: string;
                        type: "matches";
                        path: string;
                    } | undefined, {
                        type: "error";
                    } | {
                        value: string;
                        type: "matches";
                        path: string;
                    } | {
                        type: "success";
                    } | undefined>;
                    readonly max_retries: s.Schema<s.ISchemaOptions, number | undefined, number | undefined>;
                }, s.Merge<s.IObjectOptions & {
                    additionalProperties: false;
                }>>;
            }, s.Merge<s.IObjectOptions & {
                additionalProperties: false;
            }>>;
        } & s.Schema<s.ISchemaOptions, {
            [x: string]: {
                config: {
                    condition?: {
                        type: "success";
                    } | {
                        type: "error";
                    } | {
                        value: string;
                        type: "matches";
                        path: string;
                    } | undefined;
                    max_retries?: number | undefined;
                };
                target: string;
                source: string;
            };
        } | undefined, {
            [x: string]: {
                config: {
                    condition?: {
                        type: "error";
                    } | {
                        value: string;
                        type: "matches";
                        path: string;
                    } | {
                        type: "success";
                    } | undefined;
                    max_retries?: number | undefined;
                };
                target: string;
                source: string;
            };
        } | undefined>;
        readonly start_task: {
            default?: any;
            maxLength?: number | undefined;
            minLength?: number | undefined;
            pattern?: (string | RegExp) | undefined;
            format?: string | undefined;
            enum?: (readonly any[] | any[]) | undefined;
            const?: any;
        } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
        readonly responding_task: {
            default?: any;
            maxLength?: number | undefined;
            minLength?: number | undefined;
            pattern?: (string | RegExp) | undefined;
            format?: string | undefined;
            enum?: (readonly any[] | any[]) | undefined;
            const?: any;
        } & s.Schema<s.ISchemaOptions, string | undefined, string | undefined>;
    }, s.Merge<s.IObjectOptions & {
        additionalProperties: false;
    }>>, {
        readonly default: {};
    }>;
}, s.Merge<s.IObjectOptions & {
    additionalProperties: false;
}>>;
export {};