@promptbook/azure-openai 0.52.0-1

package/umd/typings/execution/plugins/llm-execution-tools/openai/OpenAiExecutionTools.d.ts

@@ -0,0 +1,45 @@
+import type { Prompt } from '../../../../types/Prompt';
+import type { AvailableModel, LlmExecutionTools } from '../../../LlmExecutionTools';
+import type { PromptChatResult, PromptCompletionResult } from '../../../PromptResult';
+import type { OpenAiExecutionToolsOptions } from './OpenAiExecutionToolsOptions';
+/**
+ * Execution Tools for calling OpenAI API.
+ */
+export declare class OpenAiExecutionTools implements LlmExecutionTools {
+    private readonly options;
+    /**
+     * OpenAI API client.
+     */
+    private readonly openai;
+    /**
+     * Creates OpenAI Execution Tools.
+     *
+     * @param options which are relevant are directly passed to the OpenAI client
+     */
+    constructor(options: OpenAiExecutionToolsOptions);
+    /**
+     * Calls OpenAI API to use a chat model.
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Calls OpenAI API to use a complete model.
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+    /**
+     * Default model for chat variant.
+     */
+    private getDefaultChatModel;
+    /**
+     * Default model for completion variant.
+     */
+    private getDefaultCompletionModel;
+    /**
+     * List all available OpenAI models that can be used
+     */
+    listModels(): Array<AvailableModel>;
+}
+/**
+ * TODO: [🍓][♐] Allow to list compatible models with each variant
+ * TODO: Maybe Create some common util for gptChat and gptComplete
+ * TODO: Maybe make custom OpenaiError
+ */

package/umd/typings/execution/plugins/llm-execution-tools/openai/OpenAiExecutionToolsOptions.d.ts

@@ -0,0 +1,16 @@
+import type { ClientOptions } from 'openai';
+import type { string_token } from '../../../.././types/typeAliases';
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+/**
+ * Options for OpenAiExecutionTools
+ *
+ * This extends OpenAI's `ClientOptions` with are directly passed to the OpenAI client.
+ * Rest is used by the `OpenAiExecutionTools`.
+ */
+export type OpenAiExecutionToolsOptions = CommonExecutionToolsOptions & ClientOptions & {
+    /**
+     * A unique identifier representing your end-user, which can help OpenAI to monitor
+     * and detect abuse. [Learn more](/docs/guides/safety-best-practices/end-user-ids).
+     */
+    user?: string_token;
+};

package/umd/typings/execution/plugins/llm-execution-tools/openai/computeOpenaiUsage.d.ts

@@ -0,0 +1,8 @@
+import type OpenAI from 'openai';
+import type { PromptResult } from '../../../PromptResult';
+/**
+ * Computes the usage of the OpenAI API based on the response from OpenAI
+ *
+ * @throws {PromptbookExecutionError} If the usage is not defined in the response from OpenAI
+ */
+export declare function computeOpenaiUsage(rawResponse: Pick<OpenAI.Chat.Completions.ChatCompletion | OpenAI.Completions.Completion, 'model' | 'usage'>): PromptResult['usage'];

package/umd/typings/execution/plugins/llm-execution-tools/openai/computeUsage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * String value found on openai page
+ *
+ * @private within the library, used only as internal helper for `OPENAI_MODELS` and `computeUsage`
+ */
+type string_openai_price = `$${number}.${number} / ${number}M tokens`;
+/**
+ * Function computeUsage will create price per one token based on the string value found on openai page
+ *
+ * @private within the library, used only as internal helper for `OPENAI_MODELS`
+ */
+export declare function computeUsage(value: string_openai_price): number;
+export {};

package/umd/typings/execution/plugins/llm-execution-tools/openai/computeUsage.test.d.ts

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

package/umd/typings/execution/plugins/llm-execution-tools/openai/models.d.ts

@@ -0,0 +1,25 @@
+import { number_usd } from '../../../../types/typeAliases';
+import type { AvailableModel } from '../../../LlmExecutionTools';
+/**
+ * List of available OpenAI models with pricing
+ *
+ * Note: Done at 2024-05-20
+ *
+ * @see https://platform.openai.com/docs/models/
+ * @see https://openai.com/api/pricing/
+ */
+export declare const OPENAI_MODELS: Array<AvailableModel & {
+    pricing?: {
+        prompt: number_usd;
+        output: number_usd;
+    };
+}>;
+/**
+ * TODO: [🧠] Some mechanism to propagate unsureness
+ * TODO: [🕚] Make this list dynamic - dynamically can be listed modelNames but not modelVariant, legacy status, context length and pricing
+ * @see https://platform.openai.com/docs/models/gpt-4-turbo-and-gpt-4
+ * @see https://openai.com/api/pricing/
+ * @see /other/playground/playground.ts
+ * TODO: [🍓] Make better
+ * TODO: Change model titles to human eg: "gpt-4-turbo-2024-04-09" -> "GPT-4 Turbo (2024-04-09)"
+ */

package/umd/typings/execution/plugins/llm-execution-tools/remote/RemoteLlmExecutionTools.d.ts

@@ -0,0 +1,40 @@
+import type { Prompt } from '../../../../types/Prompt';
+import type { AvailableModel, LlmExecutionTools } from '../../../LlmExecutionTools';
+import type { PromptChatResult, PromptCompletionResult } from '../../../PromptResult';
+import type { RemoteLlmExecutionToolsOptions } from './RemoteLlmExecutionToolsOptions';
+/**
+ * Remote server is a proxy server that uses its execution tools internally and exposes the executor interface externally.
+ *
+ * You can simply use `RemoteExecutionTools` on client-side javascript and connect to your remote server.
+ * This is useful to make all logic on browser side but not expose your API keys or no need to use customer's GPU.
+ *
+ * @see https://github.com/webgptorg/promptbook#remote-server
+ */
+export declare class RemoteLlmExecutionTools implements LlmExecutionTools {
+    private readonly options;
+    constructor(options: RemoteLlmExecutionToolsOptions);
+    /**
+     * Creates a connection to the remote proxy server.
+     */
+    private makeConnection;
+    /**
+     * Calls remote proxy server to use a chat model.
+     */
+    gptChat(prompt: Prompt): Promise<PromptChatResult>;
+    /**
+     * Calls remote proxy server to use a completion model.
+     */
+    gptComplete(prompt: Prompt): Promise<PromptCompletionResult>;
+    /**
+     * Calls remote proxy server to use both completion or chat model.
+     */
+    private gptCommon;
+    /**
+     * List all available models that can be used
+     */
+    listModels(): Promise<Array<AvailableModel>>;
+}
+/**
+ * TODO: [🍓][♐] Allow to list compatible models with each variant
+ * TODO: [🤹‍♂️] RemoteLlmExecutionTools should extend Destroyable and implement IDestroyable
+ */

package/umd/typings/execution/plugins/llm-execution-tools/remote/RemoteLlmExecutionToolsOptions.d.ts

@@ -0,0 +1,23 @@
+import type { client_id, string_uri } from '../../../../types/typeAliases';
+import type { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+/**
+ * Options for RemoteLlmExecutionTools
+ */
+export type RemoteLlmExecutionToolsOptions = CommonExecutionToolsOptions & {
+    /**
+     * URL of the remote PROMPTBOOK server
+     * On this server will be connected to the socket.io server
+     */
+    readonly remoteUrl: URL;
+    /**
+     * Path for the Socket.io server to listen
+     *
+     * @default '/socket.io'
+     * @example '/promptbook/socket.io'
+     */
+    readonly path: string_uri;
+    /**
+     * Your client ID
+     */
+    readonly clientId: client_id;
+};

package/umd/typings/execution/plugins/llm-execution-tools/remote/interfaces/Promptbook_Server_Error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Socket.io error for remote text generation
+ *
+ * This is sent from server to client when error occurs and stops the process
+ */
+export interface Promptbook_Server_Error {
+    /**
+     * The error message which caused the error
+     */
+    readonly errorMessage: string;
+}

package/umd/typings/execution/plugins/llm-execution-tools/remote/interfaces/Promptbook_Server_Progress.d.ts

@@ -0,0 +1,12 @@
+import { TaskProgress } from '../../../../../types/TaskProgress';
+/**
+ * Socket.io progress for remote text generation
+ *
+ * This is sent from server to client arbitrarily and may be sent multiple times
+ */
+export interface Promptbook_Server_Progress {
+    /**
+     * The progress of text generation
+     */
+    readonly taskProgress: TaskProgress;
+}

package/umd/typings/execution/plugins/llm-execution-tools/remote/interfaces/Promptbook_Server_Request.d.ts

@@ -0,0 +1,17 @@
+import type { client_id } from '../../../../../types/typeAliases';
+import type { Prompt } from '../../../../../types/Prompt';
+/**
+ * Socket.io progress for remote text generation
+ *
+ * This is a request from client to server
+ */
+export interface Promptbook_Server_Request {
+    /**
+     * Client responsible for the requests
+     */
+    readonly clientId: client_id;
+    /**
+     * The Prompt to execute
+     */
+    readonly prompt: Prompt;
+}

package/umd/typings/execution/plugins/llm-execution-tools/remote/interfaces/Promptbook_Server_Response.d.ts

@@ -0,0 +1,12 @@
+import { PromptResult } from '../../../../PromptResult';
+/**
+ * Socket.io error for remote text generation
+ *
+ * This is sent from server to client when the generated text is completed
+ */
+export interface Promptbook_Server_Response {
+    /**
+     * The result of the prompt
+     */
+    promptResult: PromptResult;
+}

package/umd/typings/execution/plugins/llm-execution-tools/remote/interfaces/RemoteServerOptions.d.ts

@@ -0,0 +1,27 @@
+import type { PromptbookLibrary } from '../../../../../library/PromptbookLibrary';
+import type { client_id, string_uri } from '../../../../../types/typeAliases';
+import type { CommonExecutionToolsOptions } from '../../../../CommonExecutionToolsOptions';
+import type { LlmExecutionTools } from '../../../../LlmExecutionTools';
+export type RemoteServerOptions = CommonExecutionToolsOptions & {
+    /**
+     * Port on which the server will listen
+     */
+    readonly port: number;
+    /**
+     * Path for the Socket.io server to listen
+     *
+     * @default '/socket.io'
+     * @example '/promptbook/socket.io'
+     */
+    readonly path: string_uri;
+    /**
+     * Promptbook library to use
+     *
+     * This is used to checkl validity of the prompt to prevent DDoS
+     */
+    readonly library: PromptbookLibrary;
+    /**
+     * Creates llm execution tools for each client
+     */
+    createLlmExecutionTools(clientId: client_id): LlmExecutionTools;
+};

package/umd/typings/execution/plugins/llm-execution-tools/remote/startRemoteServer.d.ts

@@ -0,0 +1,17 @@
+import type { IDestroyable } from 'destroyable';
+import { RemoteServerOptions } from './interfaces/RemoteServerOptions';
+/**
+ * Remote server is a proxy server that uses its execution tools internally and exposes the executor interface externally.
+ *
+ * You can simply use `RemoteExecutionTools` on client-side javascript and connect to your remote server.
+ * This is useful to make all logic on browser side but not expose your API keys or no need to use customer's GPU.
+ *
+ * @see https://github.com/webgptorg/promptbook#remote-server
+ */
+export declare function startRemoteServer(options: RemoteServerOptions): IDestroyable;
+/**
+ * TODO: Handle progress - support streaming
+ * TODO: [🤹‍♂️] Do not hang up immediately but wait until client closes OR timeout
+ * TODO: [🤹‍♂️] Timeout on chat to free up resources
+ * TODO: [🃏] Pass here some security token to prevent malitious usage and/or DDoS
+ */

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

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

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

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

package/umd/typings/execution/plugins/script-execution-tools/custom-function-with-dependencies.test.d.ts

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

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

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

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

@@ -0,0 +1,20 @@
+import { ScriptExecutionTools, ScriptExecutionToolsExecuteOptions } from '../../../ScriptExecutionTools';
+import { JavascriptExecutionToolsOptions } from './JavascriptExecutionToolsOptions';
+/**
+ * ScriptExecutionTools for JavaScript implemented via eval
+ *
+ * Warning: It is used for testing and mocking
+ *          **NOT intended to use in the production** due to its unsafe nature, use `JavascriptExecutionTools` instead.
+ */
+export declare class JavascriptEvalExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options: JavascriptExecutionToolsOptions);
+    /**
+     * Executes a JavaScript
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}
+/**
+ * TODO: Put predefined functions (like removeQuotes, spaceTrim, etc.) into annotation OR pass into constructor
+ * TODO: [🧠][💙] Distinct between options passed into ExecutionTools and to ExecutionTools.execute
+ */

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

@@ -0,0 +1,4 @@
+export {};
+/**
+ * TODO: !! Make shared test between JavascriptEvalExecutionTools and JavascriptExecutionTools to test the same functionality when implemented via vm2
+ */

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

@@ -0,0 +1,20 @@
+import { ScriptExecutionTools, ScriptExecutionToolsExecuteOptions } from '../../../ScriptExecutionTools';
+import { JavascriptExecutionToolsOptions } from './JavascriptExecutionToolsOptions';
+/**
+ * ScriptExecutionTools for JavaScript implemented via vm2
+ *
+ * Warning: This is not implemented yet
+ */
+export declare class JavascriptExecutionTools implements ScriptExecutionTools {
+    private readonly options;
+    constructor(options: JavascriptExecutionToolsOptions);
+    /**
+     * Executes a JavaScript
+     */
+    execute(options: ScriptExecutionToolsExecuteOptions): Promise<string>;
+}
+/**
+ * TODO: !! Pass isVerbose to constructor and use it
+ * TODO: !! Probbably make some common util createStatementToEvaluate
+ * TODO: !! Implement via vm2
+ */

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,15 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { ScriptExecutionTools, 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,15 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { ScriptExecutionTools, 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,14 @@
+import { UserInterfaceTools, UserInterfaceToolsPromptDialogOptions } from '../../../UserInterfaceTools';
+import { 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,16 @@
+import { CommonExecutionToolsOptions } from '../../../CommonExecutionToolsOptions';
+import { UserInterfaceTools, 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 { 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 { 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 { AutomaticTranslator } from './AutomaticTranslator';
+import { 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 { AutomaticTranslator } from './automatic-translators/AutomaticTranslator';
+import { TranslatorOptions } from './automatic-translators/TranslatorOptions';
+export declare function translateMessages({ automaticTranslator, from, to, }: {
+    automaticTranslator: AutomaticTranslator;
+} & TranslatorOptions): Promise<void>;

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/replaceParameters.d.ts

@@ -0,0 +1,13 @@
+import { Parameters } from '../../types/Parameters';
+import { 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/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>;
+};