@kestra-io/kestra-sdk 1.0.0 → 1.0.9

package/dist/model/FlowGraphCluster.d.ts

@@ -0,0 +1,50 @@
+export default FlowGraphCluster;
+export type IFlowGraphCluster = {
+    cluster: AbstractGraph;
+    nodes: Array<string>;
+    parents: Array<string>;
+    start: string;
+    end: string;
+};
+/**
+  * @typedef {Object} IFlowGraphCluster
+  * @property {AbstractGraph} cluster
+  * @property {Array.<String>} nodes
+  * @property {Array.<String>} parents
+  * @property {String} start
+  * @property {String} end
+  */
+/**
+ * The FlowGraphCluster model module.
+ * @module model/FlowGraphCluster
+ * @type {IFlowGraphCluster}
+ */
+declare class FlowGraphCluster {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any): void;
+    /**
+     * Constructs a <code>FlowGraphCluster</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowGraphCluster} obj Optional instance to populate.
+     * @return {module:model/FlowGraphCluster} The populated <code>FlowGraphCluster</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowGraphCluster</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowGraphCluster</code>.
+     */
+    static validateJSON(data: any): boolean;
+    cluster: AbstractGraph;
+    nodes: string[];
+    parents: string[];
+    start: string;
+    end: string;
+}
+import AbstractGraph from './AbstractGraph';
+//# sourceMappingURL=FlowGraphCluster.d.ts.map

package/dist/model/FlowGraphCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowGraphCluster.d.ts","sourceRoot":"","sources":["../../src/model/FlowGraphCluster.js"],"names":[],"mappings":";;aAkBe,aAAa;WACb,KAAK,QAAS;aACd,KAAK,QAAS;;;;AAJ7B;;;;;;;IAOI;AAEJ;;;;GAIG;AACH;IAUI;;;;OAIG;IACH,kCACC;IAED;;;;;;OAMG;IACH,2CAHW,GAA6B,GAC5B,GAA6B,CAuBxC;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAyBlB;;;;;;CAGJ;0BA/FyB,iBAAiB"}

package/dist/model/FlowGraphEdge.d.ts

@@ -0,0 +1,44 @@
+export default FlowGraphEdge;
+export type IFlowGraphEdge = {
+    source: string;
+    target: string;
+    relation: Relation;
+};
+/**
+  * @typedef {Object} IFlowGraphEdge
+  * @property {String} source
+  * @property {String} target
+  * @property {Relation} relation
+  */
+/**
+ * The FlowGraphEdge model module.
+ * @module model/FlowGraphEdge
+ * @type {IFlowGraphEdge}
+ */
+declare class FlowGraphEdge {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any): void;
+    /**
+     * Constructs a <code>FlowGraphEdge</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowGraphEdge} obj Optional instance to populate.
+     * @return {module:model/FlowGraphEdge} The populated <code>FlowGraphEdge</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowGraphEdge</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowGraphEdge</code>.
+     */
+    static validateJSON(data: any): boolean;
+    source: string;
+    target: string;
+    relation: Relation;
+}
+import Relation from './Relation';
+//# sourceMappingURL=FlowGraphEdge.d.ts.map

package/dist/model/FlowGraphEdge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowGraphEdge.d.ts","sourceRoot":"","sources":["../../src/model/FlowGraphEdge.js"],"names":[],"mappings":";;;;cAoBe,QAAQ;;AAJvB;;;;;IAKI;AAEJ;;;;GAIG;AACH;IAUI;;;;OAIG;IACH,kCACC;IAED;;;;;;OAMG;IACH,2CAHW,GAA0B,GACzB,GAA0B,CAiBrC;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAiBlB;;;;CAGJ;qBA/EoB,YAAY"}

package/dist/model/FlowId.d.ts

@@ -0,0 +1,46 @@
+export default FlowId;
+export type IFlowId = {
+    id: string;
+    namespace: string;
+    revision: number;
+    tenantId: string;
+};
+/**
+  * @typedef {Object} IFlowId
+  * @property {String} id
+  * @property {String} namespace
+  * @property {Number} revision
+  * @property {String} tenantId
+  */
+/**
+ * The FlowId model module.
+ * @module model/FlowId
+ * @type {IFlowId}
+ */
+declare class FlowId {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any): void;
+    /**
+     * Constructs a <code>FlowId</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowId} obj Optional instance to populate.
+     * @return {module:model/FlowId} The populated <code>FlowId</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowId</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowId</code>.
+     */
+    static validateJSON(data: any): boolean;
+    id: string;
+    namespace: string;
+    revision: number;
+    tenantId: string;
+}
+//# sourceMappingURL=FlowId.d.ts.map

package/dist/model/FlowId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowId.d.ts","sourceRoot":"","sources":["../../src/model/FlowId.js"],"names":[],"mappings":";;;;;;;AAeA;;;;;;IAMI;AAEJ;;;;GAIG;AACH;IAUI;;;;OAIG;IACH,kCACC;IAED;;;;;;OAMG;IACH,2CAHW,GAAmB,GAClB,GAAmB,CAoB9B;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAiBlB;;;;;CAGJ"}

package/dist/model/FlowInterface.d.ts

@@ -0,0 +1,81 @@
+export default FlowInterface;
+export type IFlowInterface = {
+    id: string;
+    namespace: string;
+    revision: number;
+    tenantId: string;
+    deleted: boolean;
+    description: string;
+    disabled: boolean;
+    /**
+     * :model/Label>} labels
+     */
+    "": Array<NodeJS.Module>;
+    variables: any;
+    workerGroup: WorkerGroup;
+    concurrency: Concurrency;
+    source: string;
+};
+/**
+  * @typedef {Object} IFlowInterface
+  * @property {String} id
+  * @property {String} namespace
+  * @property {Number} revision
+  * @property {String} tenantId
+  * @property {Boolean} deleted
+  * @property {String} description
+  * @property {Boolean} disabled
+  * @property {Array.<module:model/Label>} labels
+  * @property {Array.<module:model/InputObject>} inputs
+  * @property {Array.<module:model/Output>} outputs
+  * @property {Object.<String, Object>} variables
+  * @property {WorkerGroup} workerGroup
+  * @property {Concurrency} concurrency
+  * @property {Array.<module:model/SLA>} sla
+  * @property {String} source
+  */
+/**
+ * The FlowInterface model module.
+ * @module model/FlowInterface
+ * @type {IFlowInterface}
+ */
+declare class FlowInterface {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any): void;
+    /**
+     * Constructs a <code>FlowInterface</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowInterface} obj Optional instance to populate.
+     * @return {module:model/FlowInterface} The populated <code>FlowInterface</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowInterface</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowInterface</code>.
+     */
+    static validateJSON(data: any): boolean;
+    id: string;
+    namespace: string;
+    revision: number;
+    tenantId: string;
+    deleted: boolean;
+    description: string;
+    disabled: boolean;
+    labels: any;
+    inputs: any;
+    outputs: any;
+    variables: any;
+    workerGroup: WorkerGroup;
+    concurrency: Concurrency;
+    sla: any;
+    source: string;
+}
+import WorkerGroup from './WorkerGroup';
+import Concurrency from './Concurrency';
+//# sourceMappingURL=FlowInterface.d.ts.map

package/dist/model/FlowInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowInterface.d.ts","sourceRoot":"","sources":["../../src/model/FlowInterface.js"],"names":[],"mappings":";;;;;;;;;;;;QAiCe,KAAK,eAAQ;;iBAIb,WAAW;iBACX,WAAW;;;AAd1B;;;;;;;;;;;;;;;;;IAiBI;AAEJ;;;;GAIG;AACH;IAaI;;;;OAIG;IACH,kCACC;IAED;;;;;;OAMG;IACH,2CAHW,GAA0B,GACzB,GAA0B,CAwDrC;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAyElB;;;;;;;;;;;;;;;;CAGJ;wBA7LuB,eAAe;wBARf,eAAe"}

package/dist/model/FlowNode.d.ts

@@ -0,0 +1,52 @@
+export default FlowNode;
+export type IFlowNode = {
+    uid: string;
+    namespace: string;
+    id: string;
+};
+/**
+  * @typedef {Object} IFlowNode
+  * @property {String} uid
+  * @property {String} namespace
+  * @property {String} id
+  */
+/**
+ * The FlowNode model module.
+ * @module model/FlowNode
+ * @type {IFlowNode}
+ */
+declare class FlowNode {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any, uid: any): void;
+    /**
+     * Constructs a <code>FlowNode</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowNode} obj Optional instance to populate.
+     * @return {module:model/FlowNode} The populated <code>FlowNode</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowNode</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowNode</code>.
+     */
+    static validateJSON(data: any): boolean;
+    /**
+     * Constructs a new <code>FlowNode</code>.
+     * @alias module:model/FlowNode
+     * @param {String} uid -
+     */
+    constructor(uid: string);
+    uid: string;
+    namespace: string;
+    id: string;
+}
+declare namespace FlowNode {
+    let RequiredProperties: string[];
+}
+//# sourceMappingURL=FlowNode.d.ts.map

package/dist/model/FlowNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowNode.d.ts","sourceRoot":"","sources":["../../src/model/FlowNode.js"],"names":[],"mappings":";;;;;;AAeA;;;;;IAKI;AAEJ;;;;GAIG;AACH;IAWI;;;;OAIG;IACH,4CAEC;IAED;;;;;;OAMG;IACH,2CAHW,GAAqB,GACpB,GAAqB,CAiBhC;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAuBlB;IArED;;;;OAIG;IACH,yBAGC;;;;CAgEJ"}

package/dist/model/FlowRelation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Enum FlowRelation
+ * @type {{
+ *   "FLOW_TASK": "FLOW_TASK","FLOW_TRIGGER": "FLOW_TRIGGER",
+ * }}
+ */
+export const FlowRelationStatic: {
+    "FLOW_TASK": "FLOW_TASK";
+    "FLOW_TRIGGER": "FLOW_TRIGGER";
+};
+/**
+* Enum class FlowRelation.
+* @enum {}
+* @readonly
+*/
+export default class FlowRelation {
+    /**
+    * Returns a <code>FlowRelation</code> enum value from a Javascript object name.
+    * @param {Object} data The plain JavaScript object containing the name of the enum value.
+    * @return {module:model/FlowRelation} The enum <code>FlowRelation</code> value.
+    */
+    static constructFromObject(object: any): any;
+    /**
+     * value: "FLOW_TASK"
+     * @const
+     */
+    FLOW_TASK: string;
+    /**
+     * value: "FLOW_TRIGGER"
+     * @const
+     */
+    FLOW_TRIGGER: string;
+}
+/**
+ * *
+ */
+export type FlowRelation = any;
+//# sourceMappingURL=FlowRelation.d.ts.map

package/dist/model/FlowRelation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowRelation.d.ts","sourceRoot":"","sources":["../../src/model/FlowRelation.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,iCAJU;IACT,WAAe,EAAE,WAAW,CAAC;IAAA,cAAc,EAAE,cAAc,CAAC;CACzD,CAKH;AAED;;;;EAIE;AACF;IAiBI;;;;MAIE;IACF,yCAFW,GAAyB,CAInC;IAtBG;;;OAGG;IACH,kBAA0B;IAG1B;;;OAGG;IACH,qBAAgC;CAYvC"}

package/dist/model/FlowScope.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Enum FlowScope
+ * @type {{
+ *   "USER": "USER","SYSTEM": "SYSTEM",
+ * }}
+ */
+export const FlowScopeStatic: {
+    "USER": "USER";
+    "SYSTEM": "SYSTEM";
+};
+/**
+* Enum class FlowScope.
+* @enum {}
+* @readonly
+*/
+export default class FlowScope {
+    /**
+    * Returns a <code>FlowScope</code> enum value from a Javascript object name.
+    * @param {Object} data The plain JavaScript object containing the name of the enum value.
+    * @return {module:model/FlowScope} The enum <code>FlowScope</code> value.
+    */
+    static constructFromObject(object: any): any;
+    /**
+     * value: "USER"
+     * @const
+     */
+    USER: string;
+    /**
+     * value: "SYSTEM"
+     * @const
+     */
+    SYSTEM: string;
+}
+/**
+ * *
+ */
+export type FlowScope = any;
+//# sourceMappingURL=FlowScope.d.ts.map

package/dist/model/FlowScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowScope.d.ts","sourceRoot":"","sources":["../../src/model/FlowScope.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,8BAJU;IACT,MAAU,EAAE,MAAM,CAAC;IAAA,QAAQ,EAAE,QAAQ,CAAC;CACnC,CAKH;AAED;;;;EAIE;AACF;IAiBI;;;;MAIE;IACF,yCAFW,GAAsB,CAIhC;IAtBG;;;OAGG;IACH,aAAgB;IAGhB;;;OAGG;IACH,eAAoB;CAY3B"}

package/dist/model/FlowTopologyGraph.d.ts

@@ -0,0 +1,42 @@
+export default FlowTopologyGraph;
+export type IFlowTopologyGraph = {
+    /**
+     * :model/FlowNode>} nodes
+     */
+    "": Array<NodeJS.Module>;
+};
+/**
+  * @typedef {Object} IFlowTopologyGraph
+  * @property {Array.<module:model/FlowNode>} nodes
+  * @property {Array.<module:model/FlowTopologyGraphEdge>} edges
+  */
+/**
+ * The FlowTopologyGraph model module.
+ * @module model/FlowTopologyGraph
+ * @type {IFlowTopologyGraph}
+ */
+declare class FlowTopologyGraph {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any): void;
+    /**
+     * Constructs a <code>FlowTopologyGraph</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowTopologyGraph} obj Optional instance to populate.
+     * @return {module:model/FlowTopologyGraph} The populated <code>FlowTopologyGraph</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowTopologyGraph</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowTopologyGraph</code>.
+     */
+    static validateJSON(data: any): boolean;
+    nodes: any;
+    edges: any;
+}
+//# sourceMappingURL=FlowTopologyGraph.d.ts.map

package/dist/model/FlowTopologyGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowTopologyGraph.d.ts","sourceRoot":"","sources":["../../src/model/FlowTopologyGraph.js"],"names":[],"mappings":";;;;;QAmBe,KAAK,eAAQ;;AAF5B;;;;IAII;AAEJ;;;;GAIG;AACH;IAUI;;;;OAIG;IACH,kCACC;IAED;;;;;;OAMG;IACH,2CAHW,GAA8B,GAC7B,GAA8B,CAczC;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAyBlB;;;CAGJ"}

package/dist/model/FlowTopologyGraphEdge.d.ts

@@ -0,0 +1,44 @@
+export default FlowTopologyGraphEdge;
+export type IFlowTopologyGraphEdge = {
+    source: string;
+    target: string;
+    relation: FlowRelation;
+};
+/**
+  * @typedef {Object} IFlowTopologyGraphEdge
+  * @property {String} source
+  * @property {String} target
+  * @property {FlowRelation} relation
+  */
+/**
+ * The FlowTopologyGraphEdge model module.
+ * @module model/FlowTopologyGraphEdge
+ * @type {IFlowTopologyGraphEdge}
+ */
+declare class FlowTopologyGraphEdge {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any): void;
+    /**
+     * Constructs a <code>FlowTopologyGraphEdge</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowTopologyGraphEdge} obj Optional instance to populate.
+     * @return {module:model/FlowTopologyGraphEdge} The populated <code>FlowTopologyGraphEdge</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowTopologyGraphEdge</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowTopologyGraphEdge</code>.
+     */
+    static validateJSON(data: any): boolean;
+    source: string;
+    target: string;
+    relation: FlowRelation;
+}
+import FlowRelation from './FlowRelation';
+//# sourceMappingURL=FlowTopologyGraphEdge.d.ts.map

package/dist/model/FlowTopologyGraphEdge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowTopologyGraphEdge.d.ts","sourceRoot":"","sources":["../../src/model/FlowTopologyGraphEdge.js"],"names":[],"mappings":";;;;cAoBe,YAAY;;AAJ3B;;;;;IAKI;AAEJ;;;;GAIG;AACH;IAUI;;;;OAIG;IACH,kCACC;IAED;;;;;;OAMG;IACH,2CAHW,GAAkC,GACjC,GAAkC,CAiB7C;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAalB;;;;CAGJ;yBA3EwB,gBAAgB"}

package/dist/model/FlowUsage.d.ts

@@ -0,0 +1,49 @@
+export default FlowUsage;
+export type IFlowUsage = {
+    count: number;
+    namespacesCount: number;
+    taskTypeCount: any;
+    triggerTypeCount: any;
+    taskRunnerTypeCount: any;
+};
+/**
+  * @typedef {Object} IFlowUsage
+  * @property {Number} count
+  * @property {Number} namespacesCount
+  * @property {Object.<String, Number>} taskTypeCount
+  * @property {Object.<String, Number>} triggerTypeCount
+  * @property {Object.<String, Number>} taskRunnerTypeCount
+  */
+/**
+ * The FlowUsage model module.
+ * @module model/FlowUsage
+ * @type {IFlowUsage}
+ */
+declare class FlowUsage {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any): void;
+    /**
+     * Constructs a <code>FlowUsage</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowUsage} obj Optional instance to populate.
+     * @return {module:model/FlowUsage} The populated <code>FlowUsage</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowUsage</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowUsage</code>.
+     */
+    static validateJSON(data: any): boolean;
+    count: number;
+    namespacesCount: number;
+    taskTypeCount: any;
+    triggerTypeCount: any;
+    taskRunnerTypeCount: any;
+}
+//# sourceMappingURL=FlowUsage.d.ts.map

package/dist/model/FlowUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowUsage.d.ts","sourceRoot":"","sources":["../../src/model/FlowUsage.js"],"names":[],"mappings":";;;;;;;;AAeA;;;;;;;IAOI;AAEJ;;;;GAIG;AACH;IAUI;;;;OAIG;IACH,kCACC;IAED;;;;;;OAMG;IACH,2CAHW,GAAsB,GACrB,GAAsB,CAuBjC;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAKlB;;;;;;CAGJ"}

package/dist/model/FlowWithSource.d.ts

@@ -0,0 +1,105 @@
+export default FlowWithSource;
+export type IFlowWithSource = {
+    id: string;
+    namespace: string;
+    revision: number;
+    description: string;
+    /**
+     * :model/InputObject>} inputs
+     */
+    "": Array<NodeJS.Module>;
+    disabled: boolean;
+    variables: any;
+    workerGroup: WorkerGroup;
+    deleted: boolean;
+    concurrency: Concurrency;
+    retry: any;
+};
+/**
+  * @typedef {Object} IFlowWithSource
+  * @property {String} id
+  * @property {String} namespace
+  * @property {Number} revision
+  * @property {String} description
+  * @property {Array.<module:model/InputObject>} inputs
+  * @property {Array.<module:model/Output>} outputs - Output values make information about the execution of your Flow available and expose for other Kestra flows to use. Output values are similar to return values in programming languages.
+  * @property {Boolean} disabled
+  * @property {Array.<module:model/Label>} labels - Labels as a list of Label (key/value pairs) or as a map of string to string.
+  * @property {Object} variables
+  * @property {WorkerGroup} workerGroup
+  * @property {Boolean} deleted
+  * @property {Array.<module:model/Task>} finally
+  * @property {Array.<module:model/Task>} tasks
+  * @property {Array.<module:model/Task>} errors
+  * @property {Array.<module:model/Task>} afterExecution
+  * @property {Array.<module:model/AbstractTrigger>} triggers
+  * @property {Array.<module:model/PluginDefault>} pluginDefaults
+  * @property {Concurrency} concurrency
+  * @property {Object} retry
+  * @property {Array.<module:model/SLA>} sla
+  */
+/**
+ * The FlowWithSource model module.
+ * @module model/FlowWithSource
+ * @type {IFlowWithSource}
+ */
+declare class FlowWithSource {
+    /**
+     * Initializes the fields of this object.
+     * This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
+     * Only for internal use.
+     */
+    static initialize(obj: any, id: any, namespace: any, disabled: any, deleted: any, tasks: any): void;
+    /**
+     * Constructs a <code>FlowWithSource</code> from a plain JavaScript object, optionally creating a new instance.
+     * Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @param {module:model/FlowWithSource} obj Optional instance to populate.
+     * @return {module:model/FlowWithSource} The populated <code>FlowWithSource</code> instance.
+     */
+    static constructFromObject(data: any, obj: any): any;
+    /**
+     * Validates the JSON data with respect to <code>FlowWithSource</code>.
+     * @param {Object} data The plain JavaScript object bearing properties of interest.
+     * @return {boolean} to indicate whether the JSON data is valid with respect to <code>FlowWithSource</code>.
+     */
+    static validateJSON(data: any): boolean;
+    /**
+     * Constructs a new <code>FlowWithSource</code>.
+     * @alias module:model/FlowWithSource
+     * @implements module:model/Flow
+     * @implements module:model/AbstractFlow
+     * @param {String} id -
+     * @param {String} namespace -
+     * @param {Boolean} disabled -
+     * @param {Boolean} deleted -
+     * @param {Array.<module:model/Task>} tasks -
+     */
+    constructor(id: string, namespace: string, disabled: boolean, deleted: boolean, tasks: any);
+    id: string;
+    namespace: string;
+    revision: number;
+    description: string;
+    inputs: any;
+    outputs: any;
+    disabled: boolean;
+    labels: any;
+    variables: any;
+    workerGroup: WorkerGroup;
+    deleted: boolean;
+    finally: any;
+    tasks: any;
+    errors: any;
+    afterExecution: any;
+    triggers: any;
+    pluginDefaults: any;
+    concurrency: Concurrency;
+    retry: any;
+    sla: any;
+}
+declare namespace FlowWithSource {
+    let RequiredProperties: string[];
+}
+import WorkerGroup from './WorkerGroup';
+import Concurrency from './Concurrency';
+//# sourceMappingURL=FlowWithSource.d.ts.map

package/dist/model/FlowWithSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowWithSource.d.ts","sourceRoot":"","sources":["../../src/model/FlowWithSource.js"],"names":[],"mappings":";;;;;;;;;QAgCe,KAAK,eAAQ;;;iBAKb,WAAW;;iBAQX,WAAW;;;AAnB1B;;;;;;;;;;;;;;;;;;;;;;IAsBI;AAEJ;;;;GAIG;AACH;IAiBI;;;;OAIG;IACH,oGAMC;IAED;;;;;;OAMG;IACH,2CAHW,GAA2B,GAC1B,GAA2B,CAsEtC;IAED;;;;OAIG;IACH,gCAFY,OAAO,CAmIlB;IAhPD;;;;;;;;;;OAUG;IACH,4FAGC;;;;;;;;;;;;;;;;;;;;;CAqOJ;;;;wBAnRuB,eAAe;wBARf,eAAe"}