@rlvt/workflows-openapi-client 0.0.0-14c856f

package/build/api.d.ts

@@ -0,0 +1,609 @@
+import { AxiosInstance, AxiosRequestConfig } from "axios";
+import type { WorkflowStatus } from "./definitions";
+export { WorkflowTemplates, Workflows, WorkflowStatus, Pick_SerializedWorkflow_name_or_description_or_resourceGroupIds_, Partial_SerializedWorkflow_, Partial_SerializedWorkflowVersions_, AnyValue, WithoutReadonly, WithoutWriteonly } from "./definitions";
+export default class {
+    axios: AxiosInstance;
+    constructor(configOrInstance: AxiosRequestConfig | AxiosInstance);
+    private listTemplatesWorkflow;
+    private listTemplateCategoriesWorkflow;
+    private listWorkflow;
+    private createWorkflow;
+    private getWorkflow;
+    private updateWorkflow;
+    private deleteWorkflow;
+    private publishWorkflow;
+    private run;
+    private getContentUsage;
+    get Workflow(): {
+        listTemplates: (params: {
+            name?: string;
+            categories?: string;
+            page?: number;
+            perPage?: number;
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            paginationCount: number;
+            paginationPage: number;
+            paginationLimit: number;
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: {
+                name: string;
+                categories: string[];
+                readonly id: string & {
+                    readonly?: "__readonly";
+                };
+                metadata?: {
+                    [x: string]: any;
+                };
+                icon: string;
+                slug: string;
+                feature?: string;
+                template: {
+                    entrypoints: {
+                        node: string;
+                        type: "email" | "raw";
+                    }[];
+                    nodes: {
+                        [x: string]: {
+                            name: string;
+                            metadata: {};
+                            dependencies: string[];
+                            edges: {
+                                node: string;
+                                config: {
+                                    [x: string]: any;
+                                };
+                            }[];
+                        } | {
+                            name: string;
+                            metadata: {};
+                            dependencies: string[];
+                            config: {
+                                [x: string]: any;
+                            };
+                        };
+                    };
+                };
+            }[];
+        }>>;
+        listTemplateCategories: (options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: string[];
+        }>>;
+        list: (params: {
+            name?: string;
+            resourceGroupIds?: string[];
+            status?: WorkflowStatus[];
+            sortBy?: "updatedAt" | "createdAt";
+            sortOrder?: "desc" | "asc";
+            page?: number;
+            perPage?: number;
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            paginationCount: number;
+            paginationPage: number;
+            paginationLimit: number;
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: {
+                description?: string;
+                name: string;
+                readonly updatedAt: Date & {
+                    readonly?: "__readonly";
+                };
+                readonly createdAt: Date & {
+                    readonly?: "__readonly";
+                };
+                resourceGroupIds: string[];
+                readonly status: (WorkflowStatus.DRAFT & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHING & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHED & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.ERROR & {
+                    readonly?: "__readonly";
+                });
+                readonly id: string & {
+                    readonly?: "__readonly";
+                };
+                readonly companyId: string & {
+                    readonly?: "__readonly";
+                };
+                readonly versions: {
+                    metadata?: {
+                        [x: string]: any;
+                    };
+                    readonly state: (import("./definitions").WorkflowVersionState.DRAFT & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.LIVE & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.INACTIVE & {
+                        readonly?: "__readonly";
+                    });
+                    definition: {
+                        entrypoints: {
+                            node: string;
+                            type: "email" | "raw";
+                        }[];
+                        nodes: {
+                            [x: string]: {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                edges: {
+                                    node: string;
+                                    config: {
+                                        [x: string]: any;
+                                    };
+                                }[];
+                            } | {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                config: {
+                                    [x: string]: any;
+                                };
+                            };
+                        };
+                    };
+                    readonly analyze: {
+                        readonly?: "__readonly";
+                        outputsForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                        entrypointsForNode: {
+                            [x: string]: string[];
+                        };
+                        datasForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                    };
+                }[];
+                readonly urls?: {
+                    click: string;
+                    display: string;
+                }[];
+            }[];
+        }>>;
+        create: (data: {
+            description?: string;
+            name: string;
+            resourceGroupIds: string[];
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: {
+                description?: string;
+                name: string;
+                readonly updatedAt: Date & {
+                    readonly?: "__readonly";
+                };
+                readonly createdAt: Date & {
+                    readonly?: "__readonly";
+                };
+                resourceGroupIds: string[];
+                readonly status: (WorkflowStatus.DRAFT & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHING & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHED & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.ERROR & {
+                    readonly?: "__readonly";
+                });
+                readonly id: string & {
+                    readonly?: "__readonly";
+                };
+                readonly companyId: string & {
+                    readonly?: "__readonly";
+                };
+                readonly versions: {
+                    metadata?: {
+                        [x: string]: any;
+                    };
+                    readonly state: (import("./definitions").WorkflowVersionState.DRAFT & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.LIVE & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.INACTIVE & {
+                        readonly?: "__readonly";
+                    });
+                    definition: {
+                        entrypoints: {
+                            node: string;
+                            type: "email" | "raw";
+                        }[];
+                        nodes: {
+                            [x: string]: {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                edges: {
+                                    node: string;
+                                    config: {
+                                        [x: string]: any;
+                                    };
+                                }[];
+                            } | {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                config: {
+                                    [x: string]: any;
+                                };
+                            };
+                        };
+                    };
+                    readonly analyze: {
+                        readonly?: "__readonly";
+                        outputsForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                        entrypointsForNode: {
+                            [x: string]: string[];
+                        };
+                        datasForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                    };
+                }[];
+                readonly urls?: {
+                    click: string;
+                    display: string;
+                }[];
+            };
+        }>>;
+        get: (params: {
+            id: string;
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: {
+                description?: string;
+                name: string;
+                readonly updatedAt: Date & {
+                    readonly?: "__readonly";
+                };
+                readonly createdAt: Date & {
+                    readonly?: "__readonly";
+                };
+                resourceGroupIds: string[];
+                readonly status: (WorkflowStatus.DRAFT & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHING & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHED & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.ERROR & {
+                    readonly?: "__readonly";
+                });
+                readonly id: string & {
+                    readonly?: "__readonly";
+                };
+                readonly companyId: string & {
+                    readonly?: "__readonly";
+                };
+                readonly versions: {
+                    metadata?: {
+                        [x: string]: any;
+                    };
+                    readonly state: (import("./definitions").WorkflowVersionState.DRAFT & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.LIVE & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.INACTIVE & {
+                        readonly?: "__readonly";
+                    });
+                    definition: {
+                        entrypoints: {
+                            node: string;
+                            type: "email" | "raw";
+                        }[];
+                        nodes: {
+                            [x: string]: {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                edges: {
+                                    node: string;
+                                    config: {
+                                        [x: string]: any;
+                                    };
+                                }[];
+                            } | {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                config: {
+                                    [x: string]: any;
+                                };
+                            };
+                        };
+                    };
+                    readonly analyze: {
+                        readonly?: "__readonly";
+                        outputsForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                        entrypointsForNode: {
+                            [x: string]: string[];
+                        };
+                        datasForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                    };
+                }[];
+                readonly urls?: {
+                    click: string;
+                    display: string;
+                }[];
+            };
+        }>>;
+        update: (params: {
+            id: string;
+        }, data: {
+            description?: string;
+            name?: string;
+            resourceGroupIds?: string[];
+        } & {
+            metadata?: {
+                [x: string]: any;
+            };
+            definition?: {
+                entrypoints: {
+                    node: string;
+                    type: "email" | "raw";
+                }[];
+                nodes: {
+                    [x: string]: {
+                        name: string;
+                        metadata: {};
+                        dependencies: string[];
+                        edges: {
+                            node: string;
+                            config: {
+                                [x: string]: any;
+                            };
+                        }[];
+                    } | {
+                        name: string;
+                        metadata: {};
+                        dependencies: string[];
+                        config: {
+                            [x: string]: any;
+                        };
+                    };
+                };
+            };
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: {
+                description?: string;
+                name: string;
+                readonly updatedAt: Date & {
+                    readonly?: "__readonly";
+                };
+                readonly createdAt: Date & {
+                    readonly?: "__readonly";
+                };
+                resourceGroupIds: string[];
+                readonly status: (WorkflowStatus.DRAFT & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHING & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHED & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.ERROR & {
+                    readonly?: "__readonly";
+                });
+                readonly id: string & {
+                    readonly?: "__readonly";
+                };
+                readonly companyId: string & {
+                    readonly?: "__readonly";
+                };
+                readonly versions: {
+                    metadata?: {
+                        [x: string]: any;
+                    };
+                    readonly state: (import("./definitions").WorkflowVersionState.DRAFT & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.LIVE & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.INACTIVE & {
+                        readonly?: "__readonly";
+                    });
+                    definition: {
+                        entrypoints: {
+                            node: string;
+                            type: "email" | "raw";
+                        }[];
+                        nodes: {
+                            [x: string]: {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                edges: {
+                                    node: string;
+                                    config: {
+                                        [x: string]: any;
+                                    };
+                                }[];
+                            } | {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                config: {
+                                    [x: string]: any;
+                                };
+                            };
+                        };
+                    };
+                    readonly analyze: {
+                        readonly?: "__readonly";
+                        outputsForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                        entrypointsForNode: {
+                            [x: string]: string[];
+                        };
+                        datasForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                    };
+                }[];
+                readonly urls?: {
+                    click: string;
+                    display: string;
+                }[];
+            };
+        }>>;
+        delete: (params: {
+            id: string;
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: {};
+        }>>;
+        publish: (params: {
+            id: string;
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: {
+                description?: string;
+                name: string;
+                readonly updatedAt: Date & {
+                    readonly?: "__readonly";
+                };
+                readonly createdAt: Date & {
+                    readonly?: "__readonly";
+                };
+                resourceGroupIds: string[];
+                readonly status: (WorkflowStatus.DRAFT & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHING & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.PUBLISHED & {
+                    readonly?: "__readonly";
+                }) | (WorkflowStatus.ERROR & {
+                    readonly?: "__readonly";
+                });
+                readonly id: string & {
+                    readonly?: "__readonly";
+                };
+                readonly companyId: string & {
+                    readonly?: "__readonly";
+                };
+                readonly versions: {
+                    metadata?: {
+                        [x: string]: any;
+                    };
+                    readonly state: (import("./definitions").WorkflowVersionState.DRAFT & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.LIVE & {
+                        readonly?: "__readonly";
+                    }) | (import("./definitions").WorkflowVersionState.INACTIVE & {
+                        readonly?: "__readonly";
+                    });
+                    definition: {
+                        entrypoints: {
+                            node: string;
+                            type: "email" | "raw";
+                        }[];
+                        nodes: {
+                            [x: string]: {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                edges: {
+                                    node: string;
+                                    config: {
+                                        [x: string]: any;
+                                    };
+                                }[];
+                            } | {
+                                name: string;
+                                metadata: {};
+                                dependencies: string[];
+                                config: {
+                                    [x: string]: any;
+                                };
+                            };
+                        };
+                    };
+                    readonly analyze: {
+                        readonly?: "__readonly";
+                        outputsForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                        entrypointsForNode: {
+                            [x: string]: string[];
+                        };
+                        datasForEntrypoint: {
+                            [x: string]: string[];
+                        };
+                    };
+                }[];
+                readonly urls?: {
+                    click: string;
+                    display: string;
+                }[];
+            };
+        }>>;
+        getContentUsage: (params: {
+            id: string;
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<{
+            status: "success";
+            program: string;
+            version: string;
+            datetime: string;
+            code?: number;
+            message: string;
+            data: string[];
+        }>>;
+    };
+    get Runner(): {
+        run: (params: {
+            id: string;
+            index: number;
+            '~ru~': string;
+            mode?: "click" | "display";
+            'no-cache'?: string;
+        }, options?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any>>;
+    };
+}

package/build/api.js

@@ -0,0 +1,82 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowStatus = void 0;
+const axios_1 = __importDefault(require("axios"));
+var definitions_1 = require("./definitions");
+Object.defineProperty(exports, "WorkflowStatus", { enumerable: true, get: function () { return definitions_1.WorkflowStatus; } });
+class default_1 {
+    constructor(configOrInstance) {
+        this.axios = 'interceptors' in configOrInstance
+            ? configOrInstance
+            : axios_1.default.create(configOrInstance);
+    }
+    listTemplatesWorkflow(params, options) {
+        return this.axios.get("/workflows/templates", Object.assign({}, {
+            params: pick(params, "name", "categories", "page", "perPage"),
+        }, options));
+    }
+    listTemplateCategoriesWorkflow(options) {
+        return this.axios.get("/workflows/templates/categories", options);
+    }
+    listWorkflow(params, options) {
+        return this.axios.get("/workflows", Object.assign({}, {
+            params: pick(params, "name", "resourceGroupIds", "status", "sortBy", "sortOrder", "page", "perPage"),
+        }, options));
+    }
+    createWorkflow(data, options) {
+        return this.axios.post("/workflows", data, options);
+    }
+    getWorkflow(params, options) {
+        return this.axios.get("/workflows/{id}".replace(/{id}/, String(params["id"])), options);
+    }
+    updateWorkflow(params, data, options) {
+        return this.axios.patch("/workflows/{id}".replace(/{id}/, String(params["id"])), data, options);
+    }
+    deleteWorkflow(params, options) {
+        return this.axios.delete("/workflows/{id}".replace(/{id}/, String(params["id"])), options);
+    }
+    publishWorkflow(params, options) {
+        return this.axios.post("/workflows/{id}/publish".replace(/{id}/, String(params["id"])), {}, options);
+    }
+    run(params, options) {
+        return this.axios.get("/workflows/run/{id}/{index}".replace(/{id}/, String(params["id"])).replace(/{index}/, String(params["index"])), Object.assign({}, {
+            params: pick(params, "~ru~", "mode", "no-cache"),
+        }, options));
+    }
+    getContentUsage(params, options) {
+        return this.axios.get("/workflows/usage/content/{id}".replace(/{id}/, String(params["id"])), options);
+    }
+    get Workflow() {
+        return {
+            listTemplates: this.listTemplatesWorkflow.bind(this),
+            listTemplateCategories: this.listTemplateCategoriesWorkflow.bind(this),
+            list: this.listWorkflow.bind(this),
+            create: this.createWorkflow.bind(this),
+            get: this.getWorkflow.bind(this),
+            update: this.updateWorkflow.bind(this),
+            delete: this.deleteWorkflow.bind(this),
+            publish: this.publishWorkflow.bind(this),
+            getContentUsage: this.getContentUsage.bind(this)
+        };
+    }
+    get Runner() {
+        return {
+            run: this.run.bind(this)
+        };
+    }
+}
+exports.default = default_1;
+function pick(obj, ...keys) {
+    const ret = {};
+    keys.forEach(key => {
+        if (obj && Object.keys(obj).includes(key))
+            ret[key] = obj[key];
+    });
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/definitions.d.ts

@@ -0,0 +1,156 @@
+declare type readonlyP = {
+    readonly?: '__readonly';
+};
+declare type writeonlyP = {
+    writeonly?: '__writeonly';
+};
+declare type Primitive = string | Function | number | boolean | Symbol | undefined | null | Date;
+declare type PropsWithoutReadonly<T> = {
+    [key in keyof T]: T[key] extends readonlyP ? NonNullable<T[key]['readonly']> extends '__readonly' ? never : key : key;
+}[keyof T];
+export declare type WithoutReadonly<T> = T extends any ? T extends Primitive ? T : T extends Array<infer U> ? WithoutReadonly<U>[] : {
+    [key in keyof Pick<T, PropsWithoutReadonly<T>>]: Pick<T, PropsWithoutReadonly<T>>[key] extends any ? WithoutReadonly<Pick<T, PropsWithoutReadonly<T>>[key]> : never;
+} : never;
+declare type PropsWithoutWriteonly<T> = {
+    [key in keyof T]: T[key] extends writeonlyP ? NonNullable<T[key]['writeonly']> extends '__writeonly' ? never : key : key;
+}[keyof T];
+export declare type WithoutWriteonly<T> = T extends any ? T extends Primitive ? T : T extends Array<infer U> ? WithoutWriteonly<U>[] : {
+    [key in keyof Pick<T, PropsWithoutWriteonly<T>>]: Pick<T, PropsWithoutWriteonly<T>>[key] extends any ? WithoutWriteonly<Pick<T, PropsWithoutWriteonly<T>>[key]> : never;
+} : never;
+export declare type _node_string_type_email_or_raw__ = {
+    node: string;
+    type: "email" | "raw";
+};
+export declare type __ = {};
+export declare type AnyValue = any | null;
+export declare type __x_string__any__ = {
+    [key: string]: AnyValue;
+};
+export declare type _node_string_config___x_string__any____ = {
+    node: string;
+    config: __x_string__any__;
+};
+export declare type _name_string_metadata____dependencies_string_Array_edges__node_string_config___x_string__any_____Array__ = {
+    name: string;
+    metadata: __;
+    dependencies: string[];
+    edges: _node_string_config___x_string__any____[];
+};
+export declare type _name_string_config___x_string__any___metadata____dependencies_string_Array__ = {
+    name: string;
+    config: __x_string__any__;
+    metadata: __;
+    dependencies: string[];
+};
+export declare type __x_string___name_string_metadata____dependencies_string_Array_edges__node_string_config___x_string__any_____Array___or__name_string_config___x_string__any___metadata____dependencies_string_Array____ = {
+    [key: string]: _name_string_metadata____dependencies_string_Array_edges__node_string_config___x_string__any_____Array__ | _name_string_config___x_string__any___metadata____dependencies_string_Array__;
+};
+export declare type Workflow = {
+    entrypoints: _node_string_type_email_or_raw__[];
+    nodes: __x_string___name_string_metadata____dependencies_string_Array_edges__node_string_config___x_string__any_____Array___or__name_string_config___x_string__any___metadata____dependencies_string_Array____;
+};
+export declare type SerializedWorkflowTemplates = {
+    readonly id: (string) & readonlyP;
+    name: string;
+    icon: string;
+    slug: string;
+    categories: string[];
+    feature?: string;
+    template: Workflow;
+    metadata?: {
+        [key: string]: AnyValue;
+    };
+};
+export declare type WorkflowTemplates = SerializedWorkflowTemplates;
+export declare enum WorkflowVersionState {
+    DRAFT = "draft",
+    LIVE = "live",
+    INACTIVE = "inactive"
+}
+export declare type SerializedWorkflowVersions = {
+    metadata?: {
+        [key: string]: AnyValue;
+    };
+    readonly state: (WorkflowVersionState) & readonlyP;
+    definition: Workflow;
+    readonly analyze: ({
+        outputsForEntrypoint: {
+            [key: string]: string[];
+        };
+        entrypointsForNode: {
+            [key: string]: string[];
+        };
+        datasForEntrypoint: {
+            [key: string]: string[];
+        };
+    }) & readonlyP;
+};
+export declare type WorkflowVersions = SerializedWorkflowVersions;
+export declare enum WorkflowStatus {
+    DRAFT = "draft",
+    PUBLISHING = "publishing",
+    PUBLISHED = "published",
+    ERROR = "error"
+}
+export declare type SerializedWorkflow = {
+    readonly id: (string) & readonlyP;
+    readonly companyId: (string) & readonlyP;
+    resourceGroupIds: string[];
+    readonly versions: (WorkflowVersions[]) & readonlyP;
+    readonly createdAt: (Date) & readonlyP;
+    readonly updatedAt: (Date) & readonlyP;
+    name: string;
+    description?: string;
+    readonly urls?: ({
+        display: string;
+        click: string;
+    }[]) & readonlyP;
+    readonly status: (WorkflowStatus) & readonlyP;
+};
+export declare type Workflows = SerializedWorkflow;
+export declare type Pick_SerializedWorkflow_name_or_description_or_resourceGroupIds_ = {
+    name: string;
+    description?: string;
+    resourceGroupIds: string[];
+};
+export declare type Partial_SerializedWorkflow_ = {
+    readonly id?: (string) & readonlyP;
+    readonly companyId?: (string) & readonlyP;
+    resourceGroupIds?: string[];
+    readonly versions?: (WorkflowVersions[]) & readonlyP;
+    readonly createdAt?: (Date) & readonlyP;
+    readonly updatedAt?: (Date) & readonlyP;
+    name?: string;
+    description?: string;
+    readonly urls?: ({
+        display: string;
+        click: string;
+    }[]) & readonlyP;
+    readonly status?: (WorkflowStatus) & readonlyP;
+};
+export declare type Partial_SerializedWorkflowVersions_ = {
+    metadata?: {
+        [key: string]: AnyValue;
+    };
+    readonly state?: (WorkflowVersionState) & readonlyP;
+    definition?: Workflow;
+    readonly analyze?: ({
+        outputsForEntrypoint: {
+            [key: string]: string[];
+        };
+        entrypointsForNode: {
+            [key: string]: string[];
+        };
+        datasForEntrypoint: {
+            [key: string]: string[];
+        };
+    }) & readonlyP;
+};
+export declare type Error = {
+    path: string;
+    message: string;
+    payload?: {
+        [key: string]: AnyValue;
+    };
+};
+export {};

package/build/definitions.js

@@ -0,0 +1,19 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowStatus = exports.WorkflowVersionState = void 0;
+var WorkflowVersionState;
+(function (WorkflowVersionState) {
+    WorkflowVersionState["DRAFT"] = "draft";
+    WorkflowVersionState["LIVE"] = "live";
+    WorkflowVersionState["INACTIVE"] = "inactive";
+})(WorkflowVersionState = exports.WorkflowVersionState || (exports.WorkflowVersionState = {}));
+var WorkflowStatus;
+(function (WorkflowStatus) {
+    WorkflowStatus["DRAFT"] = "draft";
+    WorkflowStatus["PUBLISHING"] = "publishing";
+    WorkflowStatus["PUBLISHED"] = "published";
+    WorkflowStatus["ERROR"] = "error";
+})(WorkflowStatus = exports.WorkflowStatus || (exports.WorkflowStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5pdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9kZWZpbml0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsb0JBQW9CO0FBQ3BCLG9CQUFvQjs7O0FBNkVwQixJQUFZLG9CQUlYO0FBSkQsV0FBWSxvQkFBb0I7SUFDNUIsdUNBQWUsQ0FBQTtJQUNmLHFDQUFhLENBQUE7SUFDYiw2Q0FBcUIsQ0FBQTtBQUN6QixDQUFDLEVBSlcsb0JBQW9CLEdBQXBCLDRCQUFvQixLQUFwQiw0QkFBb0IsUUFJL0I7QUFzQkQsSUFBWSxjQUtYO0FBTEQsV0FBWSxjQUFjO0lBQ3RCLGlDQUFlLENBQUE7SUFDZiwyQ0FBeUIsQ0FBQTtJQUN6Qix5Q0FBdUIsQ0FBQTtJQUN2QixpQ0FBZSxDQUFBO0FBQ25CLENBQUMsRUFMVyxjQUFjLEdBQWQsc0JBQWMsS0FBZCxzQkFBYyxRQUt6QiJ9

package/build/index.d.ts

@@ -0,0 +1,8 @@
+import Api from './api';
+export * from './api';
+export default Api;
+declare type Unpromisify<T> = T extends Promise<infer U> ? U : T;
+export declare type FunctionParamsForMethod<T extends Exclude<keyof InstanceType<typeof Api>, 'axios'>, U extends keyof InstanceType<typeof Api>[T]> = Parameters<InstanceType<typeof Api>[T][U]>;
+export declare type ReturnForMethod<T extends Exclude<keyof InstanceType<typeof Api>, 'axios'>, U extends keyof InstanceType<typeof Api>[T]> = Unpromisify<ReturnType<InstanceType<typeof Api>[T][U]>>['data']['data'];
+export declare type BodyForMethod<T extends Exclude<keyof InstanceType<typeof Api>, 'axios'>, U extends keyof InstanceType<typeof Api>[T]> = FunctionParamsForMethod<T, U>[1];
+export declare type ParamsForMethod<T extends Exclude<keyof InstanceType<typeof Api>, 'axios'>, U extends keyof InstanceType<typeof Api>[T]> = FunctionParamsForMethod<T, U>[0];

package/build/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = __importDefault(require("./api"));
+__exportStar(require("./api"), exports);
+exports.default = api_1.default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7QUFBQSxnREFBdUI7QUFFdkIsd0NBQXFCO0FBQ3JCLGtCQUFlLGFBQUcsQ0FBQSJ9

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@rlvt/workflows-openapi-client",
+  "version": "0.0.0-14c856f",
+  "description": "Openapi client for reelevant service",
+  "main": "build/index.js",
+  "repository": "https://github.com/reelevant-tech/openapi-clients",
+  "author": "Reelevant",
+  "license": "MIT",
+  "publishconfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc --project .",
+    "prepublish": "yarn build"
+  },
+  "dependencies": {
+    "axios": "^0.21.1"
+  },
+  "devDependencies": {
+    "@types/axios": "^0.14.0",
+    "@types/node": "^14.14.6",
+    "typescript": "^4.0.3"
+  }
+}