@serverlessworkflow/sdk 1.0.0-alpha5.0

package/lib/generated/classes/flow-directive.d.ts

@@ -0,0 +1,44 @@
+/*****************************************************************************************
+ *
+ * /!\ This file is computer generated. Any manual modification can and will be lost. /!\
+ *
+ *****************************************************************************************/
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the FlowDirective class and type
+ */
+export type FlowDirectiveIntersection = FlowDirective & Specification.FlowDirective;
+/**
+ * Represents a constructor for the intersection of the FlowDirective class and type
+ */
+export interface FlowDirectiveConstructor {
+    new (model?: Partial<Specification.FlowDirective>): FlowDirectiveIntersection;
+}
+/**
+ * Represents a FlowDirective with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class FlowDirective extends ObjectHydrator<Specification.FlowDirective> {
+    /**
+     * Instanciates a new instance of the FlowDirective class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the FlowDirective.
+     */
+    constructor(model?: Partial<Specification.FlowDirective>);
+    /**
+     * Validates the current instance of the FlowDirective.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the FlowDirective.
+     * Creates a copy of the FlowDirective, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the FlowDirective instance.
+     */
+    normalize(): FlowDirective & Specification.FlowDirective;
+}
+export declare const _FlowDirective: FlowDirectiveConstructor;
+//# sourceMappingURL=flow-directive.d.ts.map

package/lib/generated/classes/flow-directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-directive.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/flow-directive.ts"],"names":[],"mappings":"AAgBA;;;;2FAI2F;AAE3F,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,GAAG,yBAAyB,CAAC;CAC/E;AAED;;;GAGG;AACH,qBAAa,aAAc,SAAQ,cAAc,CAAC,aAAa,CAAC,aAAa,CAAC;IAC5E;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC;IAMxD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,aAAa,GAAG,aAAa,CAAC,aAAa;CAIzD;AAED,eAAO,MAAM,cAAc,EAAoB,wBAAwB,CAAC"}

package/lib/generated/classes/for-task-configuration.d.ts

@@ -0,0 +1,44 @@
+/*****************************************************************************************
+ *
+ * /!\ This file is computer generated. Any manual modification can and will be lost. /!\
+ *
+ *****************************************************************************************/
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the ForTaskConfiguration class and type
+ */
+export type ForTaskConfigurationIntersection = ForTaskConfiguration & Specification.ForTaskConfiguration;
+/**
+ * Represents a constructor for the intersection of the ForTaskConfiguration class and type
+ */
+export interface ForTaskConfigurationConstructor {
+    new (model?: Partial<Specification.ForTaskConfiguration>): ForTaskConfigurationIntersection;
+}
+/**
+ * Represents a ForTaskConfiguration with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class ForTaskConfiguration extends ObjectHydrator<Specification.ForTaskConfiguration> {
+    /**
+     * Instanciates a new instance of the ForTaskConfiguration class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the ForTaskConfiguration.
+     */
+    constructor(model?: Partial<Specification.ForTaskConfiguration>);
+    /**
+     * Validates the current instance of the ForTaskConfiguration.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the ForTaskConfiguration.
+     * Creates a copy of the ForTaskConfiguration, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the ForTaskConfiguration instance.
+     */
+    normalize(): ForTaskConfiguration & Specification.ForTaskConfiguration;
+}
+export declare const _ForTaskConfiguration: ForTaskConfigurationConstructor;
+//# sourceMappingURL=for-task-configuration.d.ts.map

package/lib/generated/classes/for-task-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-task-configuration.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/for-task-configuration.ts"],"names":[],"mappings":"AAgBA;;;;2FAI2F;AAE3F,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C;;GAEG;AACH,MAAM,MAAM,gCAAgC,GAAG,oBAAoB,GAAG,aAAa,CAAC,oBAAoB,CAAC;AAEzG;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,GAAG,gCAAgC,CAAC;CAC7F;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,cAAc,CAAC,aAAa,CAAC,oBAAoB,CAAC;IAC1F;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC;IAM/D;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,oBAAoB,GAAG,aAAa,CAAC,oBAAoB;CAIvE;AAED,eAAO,MAAM,qBAAqB,EAA2B,+BAA+B,CAAC"}

package/lib/generated/classes/for-task.d.ts

@@ -0,0 +1,39 @@
+import { _TaskBase } from './task-base';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the ForTask class and type
+ */
+export type ForTaskIntersection = ForTask & Specification.ForTask;
+/**
+ * Represents a constructor for the intersection of the ForTask class and type
+ */
+export interface ForTaskConstructor {
+    new (model?: Partial<Specification.ForTask>): ForTaskIntersection;
+}
+/**
+ * Represents a ForTask with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class ForTask extends _TaskBase {
+    /**
+     * Instanciates a new instance of the ForTask class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the ForTask.
+     */
+    constructor(model?: Partial<Specification.ForTask>);
+    /**
+     * Validates the current instance of the ForTask.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the ForTask.
+     * Creates a copy of the ForTask, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the ForTask instance.
+     */
+    normalize(): ForTask & Specification.ForTask;
+}
+export declare const _ForTask: ForTaskConstructor;
+//# sourceMappingURL=for-task.d.ts.map

package/lib/generated/classes/for-task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-task.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/for-task.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAK/C;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,mBAAmB,CAAC;CACnE;AAED;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,SAAS;IACpC;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC;IAelD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,OAAO,GAAG,aAAa,CAAC,OAAO;CAI7C;AAED,eAAO,MAAM,QAAQ,EAAc,kBAAkB,CAAC"}

package/lib/generated/classes/fork-task-configuration.d.ts

@@ -0,0 +1,39 @@
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the ForkTaskConfiguration class and type
+ */
+export type ForkTaskConfigurationIntersection = ForkTaskConfiguration & Specification.ForkTaskConfiguration;
+/**
+ * Represents a constructor for the intersection of the ForkTaskConfiguration class and type
+ */
+export interface ForkTaskConfigurationConstructor {
+    new (model?: Partial<Specification.ForkTaskConfiguration>): ForkTaskConfigurationIntersection;
+}
+/**
+ * Represents a ForkTaskConfiguration with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class ForkTaskConfiguration extends ObjectHydrator<Specification.ForkTaskConfiguration> {
+    /**
+     * Instanciates a new instance of the ForkTaskConfiguration class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the ForkTaskConfiguration.
+     */
+    constructor(model?: Partial<Specification.ForkTaskConfiguration>);
+    /**
+     * Validates the current instance of the ForkTaskConfiguration.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the ForkTaskConfiguration.
+     * Creates a copy of the ForkTaskConfiguration, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the ForkTaskConfiguration instance.
+     */
+    normalize(): ForkTaskConfiguration & Specification.ForkTaskConfiguration;
+}
+export declare const _ForkTaskConfiguration: ForkTaskConfigurationConstructor;
+//# sourceMappingURL=fork-task-configuration.d.ts.map

package/lib/generated/classes/fork-task-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-task-configuration.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/fork-task-configuration.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAK/C;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG,qBAAqB,GAAG,aAAa,CAAC,qBAAqB,CAAC;AAE5G;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,GAAG,iCAAiC,CAAC;CAC/F;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,cAAc,CAAC,aAAa,CAAC,qBAAqB,CAAC;IAC5F;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC;IAShE;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,qBAAqB,GAAG,aAAa,CAAC,qBAAqB;CAIzE;AAED,eAAO,MAAM,sBAAsB,EAA4B,gCAAgC,CAAC"}

package/lib/generated/classes/fork-task.d.ts

@@ -0,0 +1,39 @@
+import { _TaskBase } from './task-base';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the ForkTask class and type
+ */
+export type ForkTaskIntersection = ForkTask & Specification.ForkTask;
+/**
+ * Represents a constructor for the intersection of the ForkTask class and type
+ */
+export interface ForkTaskConstructor {
+    new (model?: Partial<Specification.ForkTask>): ForkTaskIntersection;
+}
+/**
+ * Represents a ForkTask with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class ForkTask extends _TaskBase {
+    /**
+     * Instanciates a new instance of the ForkTask class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the ForkTask.
+     */
+    constructor(model?: Partial<Specification.ForkTask>);
+    /**
+     * Validates the current instance of the ForkTask.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the ForkTask.
+     * Creates a copy of the ForkTask, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the ForkTask instance.
+     */
+    normalize(): ForkTask & Specification.ForkTask;
+}
+export declare const _ForkTask: ForkTaskConstructor;
+//# sourceMappingURL=fork-task.d.ts.map

package/lib/generated/classes/fork-task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-task.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/fork-task.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAK/C;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,oBAAoB,CAAC;CACrE;AAED;;;GAGG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACrC;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAcnD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,QAAQ,GAAG,aAAa,CAAC,QAAQ;CAI/C;AAED,eAAO,MAAM,SAAS,EAAe,mBAAmB,CAAC"}

package/lib/generated/classes/function-arguments.d.ts

@@ -0,0 +1,44 @@
+/*****************************************************************************************
+ *
+ * /!\ This file is computer generated. Any manual modification can and will be lost. /!\
+ *
+ *****************************************************************************************/
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the FunctionArguments class and type
+ */
+export type FunctionArgumentsIntersection = FunctionArguments & Specification.FunctionArguments;
+/**
+ * Represents a constructor for the intersection of the FunctionArguments class and type
+ */
+export interface FunctionArgumentsConstructor {
+    new (model?: Partial<Specification.FunctionArguments>): FunctionArgumentsIntersection;
+}
+/**
+ * Represents a FunctionArguments with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class FunctionArguments extends ObjectHydrator<Specification.FunctionArguments> {
+    /**
+     * Instanciates a new instance of the FunctionArguments class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the FunctionArguments.
+     */
+    constructor(model?: Partial<Specification.FunctionArguments>);
+    /**
+     * Validates the current instance of the FunctionArguments.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the FunctionArguments.
+     * Creates a copy of the FunctionArguments, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the FunctionArguments instance.
+     */
+    normalize(): FunctionArguments & Specification.FunctionArguments;
+}
+export declare const _FunctionArguments: FunctionArgumentsConstructor;
+//# sourceMappingURL=function-arguments.d.ts.map

package/lib/generated/classes/function-arguments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-arguments.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/function-arguments.ts"],"names":[],"mappings":"AAgBA;;;;2FAI2F;AAE3F,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,iBAAiB,GAAG,aAAa,CAAC,iBAAiB,CAAC;AAEhG;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,6BAA6B,CAAC;CACvF;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,cAAc,CAAC,aAAa,CAAC,iBAAiB,CAAC;IACpF;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC;IAM5D;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,iBAAiB,GAAG,aAAa,CAAC,iBAAiB;CAIjE;AAED,eAAO,MAAM,kBAAkB,EAAwB,4BAA4B,CAAC"}

package/lib/generated/classes/grpc-arguments.d.ts

@@ -0,0 +1,39 @@
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the GRPCArguments class and type
+ */
+export type GRPCArgumentsIntersection = GRPCArguments & Specification.GRPCArguments;
+/**
+ * Represents a constructor for the intersection of the GRPCArguments class and type
+ */
+export interface GRPCArgumentsConstructor {
+    new (model?: Partial<Specification.GRPCArguments>): GRPCArgumentsIntersection;
+}
+/**
+ * Represents a GRPCArguments with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class GRPCArguments extends ObjectHydrator<Specification.GRPCArguments> {
+    /**
+     * Instanciates a new instance of the GRPCArguments class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the GRPCArguments.
+     */
+    constructor(model?: Partial<Specification.GRPCArguments>);
+    /**
+     * Validates the current instance of the GRPCArguments.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the GRPCArguments.
+     * Creates a copy of the GRPCArguments, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the GRPCArguments instance.
+     */
+    normalize(): GRPCArguments & Specification.GRPCArguments;
+}
+export declare const _GRPCArguments: GRPCArgumentsConstructor;
+//# sourceMappingURL=grpc-arguments.d.ts.map

package/lib/generated/classes/grpc-arguments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc-arguments.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/grpc-arguments.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAK/C;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,GAAG,yBAAyB,CAAC;CAC/E;AAED;;;GAGG;AACH,qBAAa,aAAc,SAAQ,cAAc,CAAC,aAAa,CAAC,aAAa,CAAC;IAC5E;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC;IAWxD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,aAAa,GAAG,aAAa,CAAC,aAAa;CAIzD;AAED,eAAO,MAAM,cAAc,EAAoB,wBAAwB,CAAC"}

package/lib/generated/classes/http-arguments.d.ts

@@ -0,0 +1,39 @@
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the HTTPArguments class and type
+ */
+export type HTTPArgumentsIntersection = HTTPArguments & Specification.HTTPArguments;
+/**
+ * Represents a constructor for the intersection of the HTTPArguments class and type
+ */
+export interface HTTPArgumentsConstructor {
+    new (model?: Partial<Specification.HTTPArguments>): HTTPArgumentsIntersection;
+}
+/**
+ * Represents a HTTPArguments with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class HTTPArguments extends ObjectHydrator<Specification.HTTPArguments> {
+    /**
+     * Instanciates a new instance of the HTTPArguments class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the HTTPArguments.
+     */
+    constructor(model?: Partial<Specification.HTTPArguments>);
+    /**
+     * Validates the current instance of the HTTPArguments.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the HTTPArguments.
+     * Creates a copy of the HTTPArguments, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the HTTPArguments instance.
+     */
+    normalize(): HTTPArguments & Specification.HTTPArguments;
+}
+export declare const _HTTPArguments: HTTPArgumentsConstructor;
+//# sourceMappingURL=http-arguments.d.ts.map

package/lib/generated/classes/http-arguments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-arguments.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/http-arguments.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAK/C;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,GAAG,yBAAyB,CAAC;CAC/E;AAED;;;GAGG;AACH,qBAAa,aAAc,SAAQ,cAAc,CAAC,aAAa,CAAC,aAAa,CAAC;IAC5E;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC;IAYxD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,aAAa,GAAG,aAAa,CAAC,aAAa;CAIzD;AAED,eAAO,MAAM,cAAc,EAAoB,wBAAwB,CAAC"}

package/lib/generated/classes/index.d.ts

@@ -0,0 +1,161 @@
+export declare const Classes: {
+    AllEventConsumptionStrategy: import("./all-event-consumption-strategy").AllEventConsumptionStrategyConstructor;
+    AllEventConsumptionStrategyConfiguration: import("./all-event-consumption-strategy-configuration").AllEventConsumptionStrategyConfigurationConstructor;
+    AnyEventConsumptionStrategy: import("./any-event-consumption-strategy").AnyEventConsumptionStrategyConstructor;
+    AnyEventConsumptionStrategyConfiguration: import("./any-event-consumption-strategy-configuration").AnyEventConsumptionStrategyConfigurationConstructor;
+    AsyncApiArguments: import("./async-api-arguments").AsyncApiArgumentsConstructor;
+    AuthenticationPolicy: import("./authentication-policy").AuthenticationPolicyConstructor;
+    AuthenticationPolicyReference: import("./authentication-policy-reference").AuthenticationPolicyReferenceConstructor;
+    BasicAuthenticationPolicy: import("./basic-authentication-policy").BasicAuthenticationPolicyConstructor;
+    BasicAuthenticationPolicyConfiguration: import("./basic-authentication-policy-configuration").BasicAuthenticationPolicyConfigurationConstructor;
+    BasicAuthenticationProperties: import("./basic-authentication-properties").BasicAuthenticationPropertiesConstructor;
+    BearerAuthenticationPolicy: import("./bearer-authentication-policy").BearerAuthenticationPolicyConstructor;
+    BearerAuthenticationPolicyConfiguration: import("./bearer-authentication-policy-configuration").BearerAuthenticationPolicyConfigurationConstructor;
+    BearerAuthenticationProperties: import("./bearer-authentication-properties").BearerAuthenticationPropertiesConstructor;
+    CallAsyncAPI: import("./call-async-api").CallAsyncAPIConstructor;
+    CallFunction: import("./call-function").CallFunctionConstructor;
+    CallGRPC: import("./call-grpc").CallGRPCConstructor;
+    CallHTTP: import("./call-http").CallHTTPConstructor;
+    CallOpenAPI: import("./call-open-api").CallOpenAPIConstructor;
+    CallTask: import("./call-task").CallTaskConstructor;
+    Catalog: import("./catalog").CatalogConstructor;
+    CatchErrors: import("./catch-errors").CatchErrorsConstructor;
+    ConstantBackoff: import("./constant-backoff").ConstantBackoffConstructor;
+    Container: import("./container").ContainerConstructor;
+    ContainerEnvironment: import("./container-environment").ContainerEnvironmentConstructor;
+    ContainerPorts: import("./container-ports").ContainerPortsConstructor;
+    ContainerVolumes: import("./container-volumes").ContainerVolumesConstructor;
+    DigestAuthenticationPolicy: import("./digest-authentication-policy").DigestAuthenticationPolicyConstructor;
+    DigestAuthenticationPolicyConfiguration: import("./digest-authentication-policy-configuration").DigestAuthenticationPolicyConfigurationConstructor;
+    DigestAuthenticationProperties: import("./digest-authentication-properties").DigestAuthenticationPropertiesConstructor;
+    Document: import("./document").DocumentConstructor;
+    DoTask: import("./do-task").DoTaskConstructor;
+    Duration: import("./duration").DurationConstructor;
+    DurationInline: import("./duration-inline").DurationInlineConstructor;
+    EmitEventDefinition: import("./emit-event-definition").EmitEventDefinitionConstructor;
+    EmitEventWith: import("./emit-event-with").EmitEventWithConstructor;
+    EmitTask: import("./emit-task").EmitTaskConstructor;
+    EmitTaskConfiguration: import("./emit-task-configuration").EmitTaskConfigurationConstructor;
+    Endpoint: import("./endpoint").EndpointConstructor;
+    EndpointConfiguration: import("./endpoint-configuration").EndpointConfigurationConstructor;
+    EndpointUri: import("./endpoint-uri").EndpointUriConstructor;
+    Error: import("./error").ErrorConstructor;
+    ErrorInstance: import("./error-instance").ErrorInstanceConstructor;
+    ErrorType: import("./error-type").ErrorTypeConstructor;
+    EventConsumptionStrategy: import("./event-consumption-strategy").EventConsumptionStrategyConstructor;
+    EventDataschema: import("./event-dataschema").EventDataschemaConstructor;
+    EventFilter: import("./event-filter").EventFilterConstructor;
+    EventFilterCorrelate: import("./event-filter-correlate").EventFilterCorrelateConstructor;
+    EventSource: import("./event-source").EventSourceConstructor;
+    EventTime: import("./event-time").EventTimeConstructor;
+    ExponentialBackOff: import("./exponential-back-off").ExponentialBackOffConstructor;
+    Export: import("./export").ExportConstructor;
+    ExportAs: import("./export-as").ExportAsConstructor;
+    Extension: import("./extension").ExtensionConstructor;
+    ExtensionItem: import("./extension-item").ExtensionItemConstructor;
+    ExternalResource: import("./external-resource").ExternalResourceConstructor;
+    ExternalScript: import("./external-script").ExternalScriptConstructor;
+    FlowDirective: import("./flow-directive").FlowDirectiveConstructor;
+    ForkTask: import("./fork-task").ForkTaskConstructor;
+    ForkTaskConfiguration: import("./fork-task-configuration").ForkTaskConfigurationConstructor;
+    ForTask: import("./for-task").ForTaskConstructor;
+    ForTaskConfiguration: import("./for-task-configuration").ForTaskConfigurationConstructor;
+    FunctionArguments: import("./function-arguments").FunctionArgumentsConstructor;
+    GRPCArguments: import("./grpc-arguments").GRPCArgumentsConstructor;
+    HTTPArguments: import("./http-arguments").HTTPArgumentsConstructor;
+    InlineScript: import("./inline-script").InlineScriptConstructor;
+    Input: import("./input").InputConstructor;
+    InputFrom: import("./input-from").InputFromConstructor;
+    LinearBackoff: import("./linear-backoff").LinearBackoffConstructor;
+    ListenTask: import("./listen-task").ListenTaskConstructor;
+    ListenTaskConfiguration: import("./listen-task-configuration").ListenTaskConfigurationConstructor;
+    OAuth2AutenthicationData: import("./oauth2-autenthication-data").OAuth2AutenthicationDataConstructor;
+    OAuth2AutenthicationDataAudiences: import("./oauth2-autenthication-data-audiences").OAuth2AutenthicationDataAudiencesConstructor;
+    OAuth2AutenthicationDataClient: import("./oauth2-autenthication-data-client").OAuth2AutenthicationDataClientConstructor;
+    OAuth2AutenthicationDataScopes: import("./oauth2-autenthication-data-scopes").OAuth2AutenthicationDataScopesConstructor;
+    OAuth2AuthenticationPolicy: import("./oauth2-authentication-policy").OAuth2AuthenticationPolicyConstructor;
+    OAuth2AuthenticationPolicyConfiguration: import("./oauth2-authentication-policy-configuration").OAuth2AuthenticationPolicyConfigurationConstructor;
+    OAuth2AuthenticationPropertiesEndpoints: import("./oauth2-authentication-properties-endpoints").OAuth2AuthenticationPropertiesEndpointsConstructor;
+    OAuth2ConnectAuthenticationProperties: import("./oauth2-connect-authentication-properties").OAuth2ConnectAuthenticationPropertiesConstructor;
+    OAuth2Issuers: import("./oauth2-issuers").OAuth2IssuersConstructor;
+    OAuth2TokenDefinition: import("./oauth2-token-definition").OAuth2TokenDefinitionConstructor;
+    OAuth2TokenRequest: import("./oauth2-token-request").OAuth2TokenRequestConstructor;
+    OneEventConsumptionStrategy: import("./one-event-consumption-strategy").OneEventConsumptionStrategyConstructor;
+    OpenAPIArguments: import("./open-api-arguments").OpenAPIArgumentsConstructor;
+    OpenIdConnectAuthenticationPolicy: import("./open-id-connect-authentication-policy").OpenIdConnectAuthenticationPolicyConstructor;
+    OpenIdConnectAuthenticationPolicyConfiguration: import("./open-id-connect-authentication-policy-configuration").OpenIdConnectAuthenticationPolicyConfigurationConstructor;
+    OpenIdConnectAuthenticationProperties: import("./open-id-connect-authentication-properties").OpenIdConnectAuthenticationPropertiesConstructor;
+    Output: import("./output").OutputConstructor;
+    OutputAs: import("./output-as").OutputAsConstructor;
+    RaiseTask: import("./raise-task").RaiseTaskConstructor;
+    RaiseTaskConfiguration: import("./raise-task-configuration").RaiseTaskConfigurationConstructor;
+    RaiseTaskRaiseError: import("./raise-task-raise-error").RaiseTaskRaiseErrorConstructor;
+    ReferenceableAuthenticationPolicy: import("./referenceable-authentication-policy").ReferenceableAuthenticationPolicyConstructor;
+    RetryBackoff: import("./retry-backoff").RetryBackoffConstructor;
+    RetryLimit: import("./retry-limit").RetryLimitConstructor;
+    RetryLimitAttempt: import("./retry-limit-attempt").RetryLimitAttemptConstructor;
+    RetryPolicy: import("./retry-policy").RetryPolicyConstructor;
+    RetryPolicyJitter: import("./retry-policy-jitter").RetryPolicyJitterConstructor;
+    RunContainer: import("./run-container").RunContainerConstructor;
+    RunScript: import("./run-script").RunScriptConstructor;
+    RunShell: import("./run-shell").RunShellConstructor;
+    RunTask: import("./run-task").RunTaskConstructor;
+    RunTaskConfiguration: import("./run-task-configuration").RunTaskConfigurationConstructor;
+    RuntimeExpression: import("./runtime-expression").RuntimeExpressionConstructor;
+    RunWorkflow: import("./run-workflow").RunWorkflowConstructor;
+    Schedule: import("./schedule").ScheduleConstructor;
+    Schema: import("./schema").SchemaConstructor;
+    SchemaExternal: import("./schema-external").SchemaExternalConstructor;
+    SchemaInline: import("./schema-inline").SchemaInlineConstructor;
+    Script: import("./script").ScriptConstructor;
+    SecretBasedAuthenticationPolicy: import("./secret-based-authentication-policy").SecretBasedAuthenticationPolicyConstructor;
+    SetTask: import("./set-task").SetTaskConstructor;
+    SetTaskConfiguration: import("./set-task-configuration").SetTaskConfigurationConstructor;
+    Shell: import("./shell").ShellConstructor;
+    ShellArguments: import("./shell-arguments").ShellArgumentsConstructor;
+    ShellEnvironment: import("./shell-environment").ShellEnvironmentConstructor;
+    SubflowConfiguration: import("./subflow-configuration").SubflowConfigurationConstructor;
+    SubflowInput: import("./subflow-input").SubflowInputConstructor;
+    SwitchCase: import("./switch-case").SwitchCaseConstructor;
+    SwitchItem: import("./switch-item").SwitchItemConstructor;
+    SwitchTask: import("./switch-task").SwitchTaskConstructor;
+    SwitchTaskConfiguration: import("./switch-task-configuration").SwitchTaskConfigurationConstructor;
+    Task: import("./task").TaskConstructor;
+    TaskBase: import("./task-base").TaskBaseConstructor;
+    TaskBaseIf: import("./task-base-if").TaskBaseIfConstructor;
+    TaskBaseTimeout: import("./task-base-timeout").TaskBaseTimeoutConstructor;
+    TaskItem: import("./task-item").TaskItemConstructor;
+    TaskList: import("./task-list").TaskListConstructor;
+    TaskMetadata: import("./task-metadata").TaskMetadataConstructor;
+    Timeout: import("./timeout").TimeoutConstructor;
+    TryTask: import("./try-task").TryTaskConstructor;
+    TryTaskCatch: import("./try-task-catch").TryTaskCatchConstructor;
+    TryTaskCatchRetry: import("./try-task-catch-retry").TryTaskCatchRetryConstructor;
+    UriTemplate: import("./uri-template").UriTemplateConstructor;
+    Use: import("./use").UseConstructor;
+    UseAuthentications: import("./use-authentications").UseAuthenticationsConstructor;
+    UseCatalogs: import("./use-catalogs").UseCatalogsConstructor;
+    UseErrors: import("./use-errors").UseErrorsConstructor;
+    UseExtensions: import("./use-extensions").UseExtensionsConstructor;
+    UseFunctions: import("./use-functions").UseFunctionsConstructor;
+    UseRetries: import("./use-retries").UseRetriesConstructor;
+    UseSecrets: import("./use-secrets").UseSecretsConstructor;
+    UseTimeouts: import("./use-timeouts").UseTimeoutsConstructor;
+    WaitTask: import("./wait-task").WaitTaskConstructor;
+    WithAsyncAPIPayload: import("./with-async-api-payload").WithAsyncAPIPayloadConstructor;
+    WithEvent: import("./with-event").WithEventConstructor;
+    WithGRPCArguments: import("./with-grpc-arguments").WithGRPCArgumentsConstructor;
+    WithGRPCService: import("./with-grpc-service").WithGRPCServiceConstructor;
+    WithHTTPBody: import("./with-http-body").WithHTTPBodyConstructor;
+    WithHTTPHeaders: import("./with-http-headers").WithHTTPHeadersConstructor;
+    WithHTTPQuery: import("./with-http-query").WithHTTPQueryConstructor;
+    WithOpenAPIParameters: import("./with-open-api-parameters").WithOpenAPIParametersConstructor;
+    Workflow: import("./workflow").WorkflowConstructor & {
+        deserialize(text: string): import("./workflow").WorkflowIntersection;
+        serialize(workflow: Partial<import("./workflow").WorkflowIntersection>, format?: "yaml" | "json", normalize?: boolean): string;
+    };
+    WorkflowMetadata: import("./workflow-metadata").WorkflowMetadataConstructor;
+    WorkflowTags: import("./workflow-tags").WorkflowTagsConstructor;
+    WorkflowTimeout: import("./workflow-timeout").WorkflowTimeoutConstructor;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/generated/classes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/index.ts"],"names":[],"mappings":"AA4KA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4JnB,CAAC"}

package/lib/generated/classes/inline-script.d.ts

@@ -0,0 +1,44 @@
+/*****************************************************************************************
+ *
+ * /!\ This file is computer generated. Any manual modification can and will be lost. /!\
+ *
+ *****************************************************************************************/
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the InlineScript class and type
+ */
+export type InlineScriptIntersection = InlineScript & Specification.InlineScript;
+/**
+ * Represents a constructor for the intersection of the InlineScript class and type
+ */
+export interface InlineScriptConstructor {
+    new (model?: Partial<Specification.InlineScript>): InlineScriptIntersection;
+}
+/**
+ * Represents a InlineScript with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class InlineScript extends ObjectHydrator<Specification.InlineScript> {
+    /**
+     * Instanciates a new instance of the InlineScript class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the InlineScript.
+     */
+    constructor(model?: Partial<Specification.InlineScript>);
+    /**
+     * Validates the current instance of the InlineScript.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the InlineScript.
+     * Creates a copy of the InlineScript, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the InlineScript instance.
+     */
+    normalize(): InlineScript & Specification.InlineScript;
+}
+export declare const _InlineScript: InlineScriptConstructor;
+//# sourceMappingURL=inline-script.d.ts.map

package/lib/generated/classes/inline-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-script.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/inline-script.ts"],"names":[],"mappings":"AAgBA;;;;2FAI2F;AAE3F,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,wBAAwB,CAAC;CAC7E;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,cAAc,CAAC,aAAa,CAAC,YAAY,CAAC;IAC1E;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC;IAMvD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,YAAY,GAAG,aAAa,CAAC,YAAY;CAIvD;AAED,eAAO,MAAM,aAAa,EAAmB,uBAAuB,CAAC"}

package/lib/generated/classes/input-from.d.ts

@@ -0,0 +1,44 @@
+/*****************************************************************************************
+ *
+ * /!\ This file is computer generated. Any manual modification can and will be lost. /!\
+ *
+ *****************************************************************************************/
+import { ObjectHydrator } from '../../hydrator';
+import { Specification } from '../definitions';
+/**
+ * Represents the intersection between the InputFrom class and type
+ */
+export type InputFromIntersection = InputFrom & Specification.InputFrom;
+/**
+ * Represents a constructor for the intersection of the InputFrom class and type
+ */
+export interface InputFromConstructor {
+    new (model?: Partial<Specification.InputFrom>): InputFromIntersection;
+}
+/**
+ * Represents a InputFrom with methods for validation and normalization.
+ * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
+ */
+export declare class InputFrom extends ObjectHydrator<Specification.InputFrom> {
+    /**
+     * Instanciates a new instance of the InputFrom class.
+     * Initializes properties based on the provided model if it is an object.
+     *
+     * @param model - Optional partial model object to initialize the InputFrom.
+     */
+    constructor(model?: Partial<Specification.InputFrom>);
+    /**
+     * Validates the current instance of the InputFrom.
+     * Throws if invalid.
+     */
+    validate(workflow?: Partial<Specification.Workflow>): void;
+    /**
+     * Normalizes the current instance of the InputFrom.
+     * Creates a copy of the InputFrom, invokes normalization hooks if available, and returns the normalized copy.
+     *
+     * @returns A normalized version of the InputFrom instance.
+     */
+    normalize(): InputFrom & Specification.InputFrom;
+}
+export declare const _InputFrom: InputFromConstructor;
+//# sourceMappingURL=input-from.d.ts.map

package/lib/generated/classes/input-from.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-from.d.ts","sourceRoot":"","sources":["../../../../../src/lib/generated/classes/input-from.ts"],"names":[],"mappings":"AAgBA;;;;2FAI2F;AAE3F,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC,GAAG,qBAAqB,CAAC;CACvE;AAED;;;GAGG;AACH,qBAAa,SAAU,SAAQ,cAAc,CAAC,aAAa,CAAC,SAAS,CAAC;IACpE;;;;;OAKG;gBACS,KAAK,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC;IAMpD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;IAKnD;;;;;OAKG;IACH,SAAS,IAAI,SAAS,GAAG,aAAa,CAAC,SAAS;CAIjD;AAED,eAAO,MAAM,UAAU,EAAgB,oBAAoB,CAAC"}