@promptbook/node 0.56.0-3

package/umd/typings/execution/plugins/script-execution-tools/javascript/JavascriptExecutionToolsOptions.d.ts

@@ -0,0 +1,26 @@
+import type { Promisable } from 'type-fest';
+import type { string_javascript_name } from '../../../../types/typeAliases';
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+/**
+ * Options for javascript execution
+ */
+export type JavascriptExecutionToolsOptions = CommonExecutionToolsOptions & {
+    /**
+     * Functions to be executed in the JavaScript evaluation.
+     *
+     * This can be used in two ways:
+     * 1. To provide custom postprocessing functions. For this case function must receive one string and return a (promise of) string.
+     * 2. As environment for the ECECUTE SCRIPT, For this case function can be any function. [0]
+     *
+     * Note: There are also some built-in functions available:
+     *      @see ./JavascriptEvalExecutionTools.ts
+     */
+    functions?: Record<string_javascript_name, PostprocessingFunction>;
+};
+/**
+ * Function that can be used to postprocess the output of the LLM
+ */
+export type PostprocessingFunction = ((value: string) => Promisable<string>) | Function;
+/**
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */

package/umd/typings/execution/plugins/script-execution-tools/javascript/utils/preserve.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Does nothing, but preserves the function in the bundle
+ * Compiler is tricked into thinking the function is used
+ *
+ * @param value any function to preserve
+ * @returns nothing
+ */
+export declare function preserve(func: (...params: Array<any>) => unknown): void;
+/**
+ * TODO: !! [1] This maybe does memory leak
+ */

package/umd/typings/execution/plugins/script-execution-tools/javascript/utils/unknownToString.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts anything to string that can be used for debugging and logging
+ *
+ * @param value String value for logging
+ * @private Internal util
+ */
+export declare function unknownToString(value: unknown): string;

package/umd/typings/execution/plugins/script-execution-tools/postprocessing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/plugins/script-execution-tools/python/PythonExecutionTools.d.ts

@@ -0,0 +1,16 @@
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import type { ScriptExecutionTools } from '../../../ScriptExecutionTools';
+import type { ScriptExecutionToolsExecuteOptions } from '../../../ScriptExecutionTools';
+/**
+ * ScriptExecutionTools for Python
+ *
+ * Warning: This is not implemented yet
+ */
+export declare class PythonExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Executes a Python
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}

package/umd/typings/execution/plugins/script-execution-tools/script-execution-errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/plugins/script-execution-tools/script-execution-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/plugins/script-execution-tools/typescript/TypescriptExecutionTools.d.ts

@@ -0,0 +1,16 @@
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import type { ScriptExecutionTools } from '../../../ScriptExecutionTools';
+import type { ScriptExecutionToolsExecuteOptions } from '../../../ScriptExecutionTools';
+/**
+ * ScriptExecutionTools for TypeScript
+ *
+ * Warning: This is not implemented yet
+ */
+export declare class TypescriptExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Executes a TypeScript
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}

package/umd/typings/execution/plugins/user-interface-execution-tools/callback/CallbackInterfaceTools.d.ts

@@ -0,0 +1,15 @@
+import type { UserInterfaceTools } from '../../../UserInterfaceTools';
+import type { UserInterfaceToolsPromptDialogOptions } from '../../../UserInterfaceTools';
+import type { CallbackInterfaceToolsOptions } from './CallbackInterfaceToolsOptions';
+/**
+ * Delagates the user interaction to a async callback function
+ * You need to provide your own implementation of this callback function and its bind to UI.
+ */
+export declare class CallbackInterfaceTools implements UserInterfaceTools {
+    private readonly options;
+    constructor(options: CallbackInterfaceToolsOptions);
+    /**
+     * Trigger the custom callback function
+     */
+    promptDialog(options: UserInterfaceToolsPromptDialogOptions): Promise<string>;
+}

package/umd/typings/execution/plugins/user-interface-execution-tools/callback/CallbackInterfaceToolsOptions.d.ts

@@ -0,0 +1,12 @@
+import type { Promisable } from 'type-fest';
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import type { UserInterfaceToolsPromptDialogOptions } from '../../../UserInterfaceTools';
+/**
+ * Options for CallbackInterfaceTools
+ */
+export type CallbackInterfaceToolsOptions = CommonExecutionToolsOptions & {
+    /**
+     * The callback function to be called when promptDialog is called
+     */
+    callback(prompt: UserInterfaceToolsPromptDialogOptions): Promisable<string>;
+};

package/umd/typings/execution/plugins/user-interface-execution-tools/simple-prompt/SimplePromptInterfaceTools.d.ts

@@ -0,0 +1,17 @@
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import type { UserInterfaceTools } from '../../../UserInterfaceTools';
+import type { UserInterfaceToolsPromptDialogOptions } from '../../../UserInterfaceTools';
+/**
+ * Wrapper around `window.prompt` synchronous function that interacts with the user via browser prompt
+ *
+ * Warning: It is used for testing and mocking
+ *          **NOT intended to use in the production** due to its synchronous nature.
+ */
+export declare class SimplePromptInterfaceTools implements UserInterfaceTools {
+    private readonly options;
+    constructor(options: CommonExecutionToolsOptions);
+    /**
+     * Trigger window.PROMPT DIALOG
+     */
+    promptDialog(options: UserInterfaceToolsPromptDialogOptions): Promise<string>;
+}

package/umd/typings/execution/plugins/user-interface-execution-tools/user-interface-execution-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/translation/automatic-translate/automatic-translators/AutomaticTranslator.d.ts

@@ -0,0 +1,4 @@
+import type { Promisable } from 'type-fest';
+export type AutomaticTranslator = {
+    translate(message: string): Promisable<string>;
+};

package/umd/typings/execution/translation/automatic-translate/automatic-translators/DebugAutomaticTranslator.d.ts

@@ -0,0 +1,9 @@
+import type { AutomaticTranslator } from './AutomaticTranslator';
+/**
+ * This will wrap an automatic translator and log each translation into the console
+ */
+export declare class DebugAutomaticTranslator implements AutomaticTranslator {
+    private readonly automaticTranslator;
+    constructor(automaticTranslator: AutomaticTranslator);
+    translate(message: string): Promise<string>;
+}

package/umd/typings/execution/translation/automatic-translate/automatic-translators/FakeAutomaticTranslator.d.ts

@@ -0,0 +1,5 @@
+import type { AutomaticTranslator } from './AutomaticTranslator';
+export declare class FakeAutomaticTranslator implements AutomaticTranslator {
+    constructor();
+    translate(message: string): string;
+}

package/umd/typings/execution/translation/automatic-translate/automatic-translators/LindatAutomaticTranslator.d.ts

@@ -0,0 +1,11 @@
+import type { AutomaticTranslator } from './AutomaticTranslator';
+import type { TranslatorOptions } from './TranslatorOptions';
+interface LindatAutomaticTranslatorOptions extends TranslatorOptions {
+    apiUrl: URL;
+}
+export declare class LindatAutomaticTranslator implements AutomaticTranslator {
+    private readonly options;
+    constructor(options: LindatAutomaticTranslatorOptions);
+    translate(message: string): Promise<string>;
+}
+export {};

package/umd/typings/execution/translation/automatic-translate/automatic-translators/TranslatorOptions.d.ts

@@ -0,0 +1,4 @@
+export type TranslatorOptions = {
+    from: string;
+    to: string;
+};

package/umd/typings/execution/translation/automatic-translate/automatic-translators/utils/extractMultiplicatedOccurrence.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param message
+ * @returns
+ * @throws {PromptbookExecutionError}
+ */
+export declare function extractMultiplicatedOccurrence(message: string): string;

package/umd/typings/execution/translation/automatic-translate/automatic-translators/utils/extractMultiplicatedOccurrence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/translation/automatic-translate/translateMessages.d.ts

@@ -0,0 +1,5 @@
+import type { AutomaticTranslator } from './automatic-translators/AutomaticTranslator';
+import type { TranslatorOptions } from './automatic-translators/TranslatorOptions';
+export declare function translateMessages({ automaticTranslator, from, to, }: {
+    automaticTranslator: AutomaticTranslator;
+} & TranslatorOptions): Promise<void>;

package/umd/typings/execution/utils/addUsage.d.ts

@@ -0,0 +1,7 @@
+import type { PromptResultUsage } from '../PromptResult';
+/**
+ * Function `addUsage` will add multiple usages into one
+ *
+ * Note: If you provide 0 values, it returns void usage
+ */
+export declare function addUsage(...usageItems: Array<PromptResultUsage>): PromptResultUsage;

package/umd/typings/execution/utils/addUsage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/utils/checkExpectations.d.ts

@@ -0,0 +1,25 @@
+import type { Expectations } from '../../types/PromptbookJson/PromptTemplateJson';
+/**
+ * Function checkExpectations will check if the expectations on given value are met
+ *
+ * Note: There are two simmilar functions:
+ * - `checkExpectations` which throws an error if the expectations are not met
+ * - `isPassingExpectations` which returns a boolean
+ *
+ * @throws {ExpectError} if the expectations are not met
+ * @returns {void} Nothing
+ */
+export declare function checkExpectations(expectations: Expectations, value: string): void;
+/**
+ * Function checkExpectations will check if the expectations on given value are met
+ *
+ * Note: There are two simmilar functions:
+ * - `checkExpectations` which throws an error if the expectations are not met
+ * - `isPassingExpectations` which returns a boolean
+ *
+ * @returns {boolean} True if the expectations are met
+ */
+export declare function isPassingExpectations(expectations: Expectations, value: string): boolean;
+/**
+ * TODO: [💝] Unite object for expecting amount and format
+ */

package/umd/typings/execution/utils/checkExpectations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/utils/computeUsageCounts.d.ts

@@ -0,0 +1,10 @@
+import type { PromptResultUsageCounts } from '../PromptResult';
+/**
+ * Helper of usage compute
+ *
+ * @param content the content of prompt or response
+ * @returns part of PromptResultUsageCounts
+ *
+ * @private internal util of LlmExecutionTools
+ */
+export declare function computeUsageCounts(content: string): Omit<PromptResultUsageCounts, 'tokensCount'>;

package/umd/typings/execution/utils/forEachAsync.d.ts

@@ -0,0 +1,18 @@
+import type { Promisable } from 'type-fest';
+type ForEachAsyncOptions = {
+    /**
+     * Maximum number of tasks running in parallel
+     *
+     * @default Infinity
+     */
+    inParallelCount?: number;
+};
+/**
+ * Async version of Array.forEach
+ *
+ * @param array - Array to iterate over
+ * @param options - Options for the function
+ * @param callbackfunction - Function to call for each item
+ */
+export declare function forEachAsync<TItem>(array: Array<TItem>, options: ForEachAsyncOptions, callbackfunction: (value: TItem, index: number, array: Array<TItem>) => Promisable<void>): Promise<void>;
+export {};

package/umd/typings/execution/utils/replaceParameters.d.ts

@@ -0,0 +1,13 @@
+import type { Parameters } from '../../types/Parameters';
+import type { string_template } from '../../types/typeAliases';
+/**
+ * Replaces parameters in template with values from parameters object
+ *
+ * @param template the template with parameters in {curly} braces
+ * @param parameters the object with parameters
+ * @returns the template with replaced parameters
+ * @throws {TemplateError} if parameter is not defined, not closed, or not opened
+ *
+ * @private within the createPromptbookExecutor
+ */
+export declare function replaceParameters(template: string_template, parameters: Parameters): string;

package/umd/typings/execution/utils/replaceParameters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/execution/utils/uncertainNumber.d.ts

@@ -0,0 +1,9 @@
+import type { UncertainNumber } from '../PromptResult';
+/**
+ * Make UncertainNumber
+ *
+ * @param value
+ *
+ * @private utility for initializating UncertainNumber
+ */
+export declare function uncertainNumber(value?: number | typeof NaN | undefined | null): UncertainNumber;

package/umd/typings/execution/utils/usageToWorktime.d.ts

@@ -0,0 +1,10 @@
+import type { PromptResultUsage } from '../PromptResult';
+import type { UncertainNumber } from '../PromptResult';
+/**
+ * Function usageToWorktime will take usage and estimate saved worktime in hours of reading / writing
+ *
+ * Note: This is an estimate based of theese sources:
+ * - https://jecas.cz/doba-cteni
+ * - https://www.originalnitonery.cz/blog/psani-vsemi-deseti-se-muzete-naucit-i-sami-doma
+ */
+export declare function usageToWorktime(usage: PromptResultUsage): UncertainNumber;

package/umd/typings/execution/utils/usageToWorktime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/library/PromptbookLibrary.d.ts

@@ -0,0 +1,25 @@
+import type { Promisable } from 'type-fest';
+import type { Prompt } from '../types/Prompt';
+import type { PromptbookJson } from '../types/PromptbookJson/PromptbookJson';
+import type { string_promptbook_url } from '../types/typeAliases';
+/**
+ * Library of promptbooks that groups together promptbooks for an application.
+ *
+ * @see https://github.com/webgptorg/promptbook#promptbook-library
+ */
+export type PromptbookLibrary = {
+    /**
+     * Gets all promptbooks in the library
+     */
+    listPromptbooks(): Promisable<Array<string_promptbook_url>>;
+    /**
+     * Gets promptbook by its URL
+     *
+     * Note: This is not a direct fetching from the URL, but a lookup in the library
+     */
+    getPromptbookByUrl(url: string_promptbook_url): Promisable<PromptbookJson>;
+    /**
+     * Checks whether given prompt was defined in any promptbook in the library
+     */
+    isResponsibleForPrompt(prompt: Prompt): Promisable<boolean>;
+};

package/umd/typings/library/SimplePromptbookLibrary.d.ts

@@ -0,0 +1,36 @@
+import type { Prompt } from '../types/Prompt';
+import type { PromptbookJson } from '../types/PromptbookJson/PromptbookJson';
+import type { string_promptbook_url } from '../types/typeAliases';
+import type { PromptbookLibrary } from './PromptbookLibrary';
+/**
+ * Library of promptbooks that groups together promptbooks for an application.
+ * This implementation is a very thin wrapper around the Array / Map of promptbooks.
+ *
+ * @see https://github.com/webgptorg/promptbook#promptbook-library
+ */
+export declare class SimplePromptbookLibrary implements PromptbookLibrary {
+    private library;
+    /**
+     * Constructs a promptbook library from promptbooks
+     *
+     * @param promptbooks !!!
+     *
+     * Note: During the construction logic of all promptbooks are validated
+     * Note: It is not recommended to use this constructor directly, use `createPromptbookLibraryFromSources` *(or other variant)* instead
+     */
+    constructor(...promptbooks: Array<PromptbookJson>);
+    /**
+     * Gets all promptbooks in the library
+     */
+    listPromptbooks(): Array<string_promptbook_url>;
+    /**
+     * Gets promptbook by its URL
+     *
+     * Note: This is not a direct fetching from the URL, but a lookup in the library
+     */
+    getPromptbookByUrl(url: string_promptbook_url): PromptbookJson;
+    /**
+     * Checks whether given prompt was defined in any promptbook in the library
+     */
+    isResponsibleForPrompt(prompt: Prompt): boolean;
+}

package/umd/typings/library/constructors/createPromptbookLibraryFromDirectory.d.ts

@@ -0,0 +1,43 @@
+import type { string_folder_path } from '../../types/typeAliases';
+import type { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Options for `createPromptbookLibraryFromDirectory` function
+ */
+type CreatePromptbookLibraryFromDirectoryOptions = {
+    /**
+     * If true, the directory is searched recursively for promptbooks
+     *
+     * @default true
+     */
+    isRecursive?: boolean;
+    /**
+     * If true, the library creation outputs information about each file it reads
+     *
+     * @default false
+     */
+    isVerbose?: boolean;
+    /**
+     * If true, directory will be scanned only when needed not during the construction
+     *
+     * @default false
+     */
+    isLazyLoaded?: boolean;
+    /**
+     * If true, whole library creation crashes on error in any promptbook
+     * If true and isLazyLoaded is true, the error is thrown on first access to the promptbook
+     *
+     * @default true
+     */
+    isCrashOnError?: boolean;
+};
+/**
+ * Constructs Promptbook from given directory
+ *
+ * Note: Works only in Node.js environment because it reads the file system
+ *
+ * @param path - path to the directory with promptbooks
+ * @param options - Misc options for the library
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookLibraryFromDirectory(path: string_folder_path, options?: CreatePromptbookLibraryFromDirectoryOptions): Promise<PromptbookLibrary>;
+export {};

package/umd/typings/library/constructors/createPromptbookLibraryFromDirectory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/library/constructors/createPromptbookLibraryFromPromise.d.ts

@@ -0,0 +1,23 @@
+import type { PromptbookJson } from '../../types/PromptbookJson/PromptbookJson';
+import type { PromptbookString } from '../../types/PromptbookString';
+import type { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Constructs Promptbook from async sources
+ * It can be one of the following:
+ * - Promise of array of PromptbookJson or PromptbookString
+ * - Factory function that returns Promise of array of PromptbookJson or PromptbookString
+ *
+ * Note: This is useful as internal tool for other constructor functions like
+ *       `createPromptbookLibraryFromUrl` or `createPromptbookLibraryFromDirectory`
+ *       Consider using those functions instead of this one
+ *
+ * Note: The function does NOT return promise it returns the library directly which waits for the sources to be resolved
+ *       when error occurs in given promise or factory function, it is thrown during `listPromptbooks` or `getPromptbookByUrl` call
+ *
+ * Note: Consider using  `createPromptbookLibraryFromDirectory` or `createPromptbookLibraryFromUrl`
+ *
+ * @param promptbookSourcesPromiseOrFactory
+ * @returns PromptbookLibrary
+ * @private Just internal tool for other constructor functions
+ */
+export declare function createPromptbookLibraryFromPromise(promptbookSourcesPromiseOrFactory: Promise<Array<PromptbookJson | PromptbookString>> | (() => Promise<Array<PromptbookJson | PromptbookString>>)): PromptbookLibrary;

package/umd/typings/library/constructors/createPromptbookLibraryFromPromise.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/library/constructors/createPromptbookLibraryFromSources.d.ts

@@ -0,0 +1,13 @@
+import type { PromptbookJson } from '../../types/PromptbookJson/PromptbookJson';
+import type { PromptbookString } from '../../types/PromptbookString';
+import { SimplePromptbookLibrary } from '../SimplePromptbookLibrary';
+/**
+ * Creates PromptbookLibrary from array of PromptbookJson or PromptbookString
+ *
+ * Note: You can combine `PromptbookString` (`.ptbk.md`) with `PromptbookJson` BUT it is not recommended
+ * Note: During the construction syntax and logic of all sources are validated
+ *
+ * @param promptbookSources
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookLibraryFromSources(...promptbookSources: Array<PromptbookJson | PromptbookString>): SimplePromptbookLibrary;

package/umd/typings/library/constructors/createPromptbookLibraryFromSources.test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/typings/library/constructors/createPromptbookLibraryFromUrl.d.ts

@@ -0,0 +1,26 @@
+import type { string_url } from '../../types/typeAliases';
+import type { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Options for `createPromptbookLibraryFromDirectory` function
+ */
+type CreatePromptbookLibraryFromUrlyOptions = {
+    /**
+     * If true, the library creation outputs information about each file it reads
+     *
+     * @default false
+     */
+    isVerbose?: boolean;
+    /**
+     * If true, directory will be scanned only when needed not during the construction
+     *
+     * @default false
+     */
+    isLazyLoaded?: boolean;
+};
+/**
+ * Constructs Promptbook from remote Promptbase URL
+
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookLibraryFromUrl(url: string_url | URL, options: CreatePromptbookLibraryFromUrlyOptions): Promise<PromptbookLibrary>;
+export {};

package/umd/typings/library/constructors/createPromptbookSublibrary.d.ts

@@ -0,0 +1,12 @@
+import type { string_promptbook_url } from '../../types/typeAliases';
+import type { PromptbookLibrary } from '../PromptbookLibrary';
+/**
+ * Creates PromptbookLibrary as a subset of another PromptbookLibrary
+ *
+ * Note: You can use any type of library as a parent library - local, remote, etc.
+ * Note: This is just a thin wrapper / proxy around the parent library
+ *
+ * @param promptbookSources
+ * @returns PromptbookLibrary
+ */
+export declare function createPromptbookSublibrary(library: PromptbookLibrary, predicate: (url: string_promptbook_url) => boolean): PromptbookLibrary;

package/umd/typings/library/constructors/justTestFsImport.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Just testing imports and compatibility
+ */
+export declare function justTestFsImport(): Promise<void>;
+/**
+ * TODO: !!! Remove this file
+ */ 

package/umd/typings/types/Command.d.ts

@@ -0,0 +1,101 @@
+import type { string_markdown_text } from './typeAliases';
+import type { string_name } from './typeAliases';
+import type { string_version } from './typeAliases';
+import type { ExecutionType } from './ExecutionTypes';
+import type { ModelRequirements } from './ModelRequirements';
+import type { ExpectationAmount } from './PromptbookJson/PromptTemplateJson';
+import type { ExpectationUnit } from './PromptbookJson/PromptTemplateJson';
+/**
+ * Command is one piece of the prompt template which adds some logic to the prompt template or the whole pipeline.
+ * It is parsed from the markdown from ul/ol items - one command per one item.
+ */
+export type Command = PromptbookUrlCommand | PromptbookVersionCommand | ExecuteCommand | ModelCommand | JokerCommand | ParameterCommand | PostprocessCommand | ExpectCommand;
+/**
+ * PromptbookVersion command tells which version is .promptbook file using
+ *
+ * - It is used for backward compatibility
+ * - It is defined per whole .promptbook file in the header
+ */
+export type PromptbookUrlCommand = {
+    readonly type: 'PROMPTBOOK_URL';
+    readonly promptbookUrl: URL;
+};
+/**
+ * PromptbookVersion command tells which version is .promptbook file using
+ *
+ * - It is used for backward compatibility
+ * - It is defined per whole .promptbook file in the header
+ */
+export type PromptbookVersionCommand = {
+    readonly type: 'PROMPTBOOK_VERSION';
+    readonly promptbookVersion: string_version;
+};
+/**
+ * Execute command tells how to execute the section
+ * It can be either prompt template, script or SIMPLE TEMPLATE etc.
+ */
+export type ExecuteCommand = {
+    readonly type: 'EXECUTE';
+    readonly executionType: ExecutionType;
+};
+/**
+ * Model command tells which model and modelRequirements to use for the prompt template. execution
+ */
+export type ModelCommand = {
+    readonly type: 'MODEL';
+    readonly key: keyof ModelRequirements;
+    readonly value: any;
+};
+/**
+ * Joker parameter is used instead of executing the prompt template if it meet the expectations requirements
+ */
+export type JokerCommand = {
+    readonly type: 'JOKER';
+    readonly parameterName: string_name;
+};
+/**
+ * Parameter command describes one parameter of the prompt template
+ *
+ * - It can tell if it is input or OUTPUT PARAMETER
+ * - It can have description
+ * - In description it can have simple formatting BUT not markdown structure or reference to other parameters
+ */
+export type ParameterCommand = {
+    readonly type: 'PARAMETER';
+    readonly isInput: boolean;
+    readonly isOutput: boolean;
+    readonly parameterName: string_name;
+    readonly parameterDescription: string_markdown_text | null;
+};
+/**
+ * Postprocess command describes which function to use for postprocessing
+ * This will be created as separate EXECUTE SCRIPT block bellow
+ */
+export type PostprocessCommand = {
+    readonly type: 'POSTPROCESS';
+    readonly functionName: string_name;
+};
+/**
+ * Expect command describes the desired output of the prompt template (after post-processing)
+ * It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs or some other shape of the output.
+ */
+export type ExpectCommand = ExpectAmountCommand | ExpectFormatCommand;
+/**
+ * Expect amount command describes the desired output of the prompt template (after post-processing)
+ * It can set limits for the maximum/minimum length of the output, measured in characters, words, sentences, paragraphs,...
+ *
+ * Note: LLMs work with tokens, not characters, but in Promptbooks we want to use some human-recognisable and cross-model interoperable units.
+ */
+export type ExpectAmountCommand = {
+    readonly type: 'EXPECT_AMOUNT';
+    readonly sign: 'EXACTLY' | 'MINIMUM' | 'MAXIMUM';
+    readonly unit: ExpectationUnit;
+    readonly amount: ExpectationAmount;
+};
+/**
+ * Represents a command that expects a specific format.
+ */
+export type ExpectFormatCommand = {
+    readonly type: 'EXPECT_FORMAT';
+    readonly format: 'JSON';
+};