@beseif-solutions/prow-core 0.0.16

package/dist/core.d.ts

@@ -0,0 +1,21 @@
+import axios from "axios";
+import _ from "lodash";
+import moment from "moment-timezone";
+import { Env } from "./minified-utils/env";
+import { i18n } from "./minified-utils/locales";
+import Joi from "joi";
+export type Core = {
+    axios: typeof axios;
+    moment: typeof moment;
+    lodash: typeof _;
+    env: Env;
+    t: ReturnType<typeof i18n>[`t`];
+    joi: typeof Joi;
+};
+type CoreOptions = {
+    path: string;
+    debug?: boolean;
+    locale?: string;
+};
+export declare const core: (options: CoreOptions) => Core;
+export {};

package/dist/core.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.core = void 0;
+const axios_1 = __importDefault(require("axios"));
+const lodash_1 = __importDefault(require("lodash"));
+const moment_timezone_1 = __importDefault(require("moment-timezone"));
+const proxy_1 = require("./minified-utils/proxy");
+const env_1 = require("./minified-utils/env");
+const locales_1 = require("./minified-utils/locales");
+const path_1 = __importDefault(require("path"));
+const joi_1 = __importDefault(require("joi"));
+const axiosLogs = (method, debug = false) => ({
+    before: (name, [url]) => {
+        if (debug) {
+            console.log(`> [${method}]`, url);
+        }
+    },
+    after: (name, response) => {
+        if (debug) {
+            console.log(`< [${method}]`, response.config.url, response.status);
+        }
+    },
+    error: (name, error) => {
+        if (debug) {
+            console.log(`< [${method}]`, error.config.url, error.status);
+        }
+    },
+});
+const core = (options) => ({
+    axios: (0, proxy_1.accessProxy)(axios_1.default, {
+        get: (0, proxy_1.logProxy)(`axios.get`, axios_1.default.get, axiosLogs(`GET`, options.debug)),
+        post: (0, proxy_1.logProxy)(`axios.post`, axios_1.default.post, axiosLogs(`POST`, options.debug)),
+        put: (0, proxy_1.logProxy)(`axios.put`, axios_1.default.put, axiosLogs(`PUT`, options.debug)),
+        patch: (0, proxy_1.logProxy)(`axios.patch`, axios_1.default.patch, axiosLogs(`PATCH`, options.debug)),
+        delete: (0, proxy_1.logProxy)(`axios.delete`, axios_1.default.delete, axiosLogs(`DELETE`, options.debug)),
+    }),
+    moment: moment_timezone_1.default,
+    lodash: lodash_1.default,
+    env: new env_1.Env(options.path),
+    t: (0, locales_1.i18n)(path_1.default.join(options.path, `/locales`), { locale: options.locale }).t,
+    joi: joi_1.default,
+});
+exports.core = core;

package/dist/entities/category.d.ts

@@ -0,0 +1 @@
+export declare const getCategories: () => Promise<string[]>;

package/dist/entities/category.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCategories = void 0;
+const axios_1 = __importDefault(require("axios"));
+const getCategories = async () => {
+    try {
+        const { data } = await axios_1.default.get(`https://dev-beseif.s3.eu-west-1.amazonaws.com/prow/categories.txt`);
+        if (!data || typeof data !== `string`) {
+            throw new Error(`Could not obtain category list`);
+        }
+        return data.split(`\n`).map((d) => d.trim());
+    }
+    catch (e) {
+        throw e;
+    }
+};
+exports.getCategories = getCategories;

package/dist/entities/commons.d.ts

@@ -0,0 +1,26 @@
+import Joi from "joi";
+import { Core } from "../core";
+export type CoreConfig = {
+    inputs?: Record<string, any>;
+    credentials?: Record<string, any>;
+    outputs?: Record<string, any>;
+};
+export type CoreFunction<Config extends CoreConfig = {}> = (core: Core, configuration: ({
+    sandbox: boolean;
+} & (Config[`inputs`] extends undefined ? {} : {
+    inputs: Config[`inputs`];
+}) & (Config[`credentials`] extends undefined ? {} : {
+    credentials: Config[`credentials`];
+}))) => Promise<Config[`outputs`]>;
+type CommonConfig = Pick<CoreConfig, `credentials`>;
+export type Common<Config extends CommonConfig = {}> = {
+    id: string;
+    helpers?: Record<string, CoreFunction<{
+        credentials: Config[`credentials`];
+        inputs: any;
+        outputs: any;
+    }>>;
+};
+export declare const idSchema: () => Joi.StringSchema<string>;
+export declare const commonSchema: () => Joi.ObjectSchema<any>;
+export {};

package/dist/entities/commons.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonSchema = exports.idSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const idSchema = () => joi_1.default.string().required().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+exports.idSchema = idSchema;
+const commonSchema = () => joi_1.default.object({
+    id: (0, exports.idSchema)(),
+    helpers: joi_1.default.object()
+        .pattern(joi_1.default.string(), joi_1.default.function()),
+});
+exports.commonSchema = commonSchema;

package/dist/entities/credentials.d.ts

@@ -0,0 +1,85 @@
+import Joi from "joi";
+import { Field } from "../minified-utils/fields";
+import { Common, CoreConfig, CoreFunction } from "./commons";
+type CredentialsConfig = Pick<CoreConfig, `credentials`>;
+type CommonCredentials<Config extends CredentialsConfig = {}> = Common<Config> & {
+    model: `credentials`;
+    sandbox: boolean;
+    functions: {
+        check: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: undefined;
+            outputs: {
+                valid: boolean;
+            };
+        }>;
+    };
+};
+export type OAuthCredentials<Config extends CredentialsConfig = {}> = CommonCredentials<Config> & {
+    type: `oauth`;
+    functions: {
+        oauth: CoreFunction<{
+            credentials: undefined;
+            inputs: {
+                redirect: string;
+            };
+            outputs: {
+                action: string;
+                method: string;
+                body: Record<string, any>;
+            };
+        }>;
+        connect: CoreFunction<{
+            credentials: undefined;
+            inputs: {
+                redirect: string;
+                code: string;
+            };
+            outputs: {
+                username?: string;
+                credentials: Config[`credentials`];
+            };
+        }>;
+        refresh: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: undefined;
+            outputs: {
+                username?: string;
+                credentials: Config[`credentials`];
+            };
+        }>;
+        disconnect: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: undefined;
+            outputs: {
+                done: true;
+            };
+        }>;
+    };
+};
+export type SessionCredentials<Config extends CredentialsConfig = {}> = CommonCredentials<Config> & {
+    type: `session`;
+    fields: Field[];
+    functions: {
+        connect: CoreFunction<{
+            credentials: undefined;
+            inputs: {
+                fields: Record<string, any>;
+            };
+            outputs: {
+                username?: string;
+                credentials: Config[`credentials`];
+            };
+        }>;
+    };
+};
+export type StaticCredentials<Config extends CredentialsConfig = {}> = CommonCredentials<Config> & {
+    type: `static`;
+    fields: Field[];
+};
+export type Credentials<Config extends CredentialsConfig = {}> = OAuthCredentials<Config> | StaticCredentials<Config> | SessionCredentials<Config>;
+export declare const oauthCredentialsSchema: () => Joi.ObjectSchema<any>;
+export declare const sessionCredentialsSchema: () => Joi.ObjectSchema<any>;
+export declare const staticCredentialsSchema: () => Joi.ObjectSchema<any>;
+export declare const credentialsSchema: () => Joi.AlternativesSchema<any>;
+export {};

package/dist/entities/credentials.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentialsSchema = exports.staticCredentialsSchema = exports.sessionCredentialsSchema = exports.oauthCredentialsSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const fields_1 = require("../minified-utils/fields");
+const commons_1 = require("./commons");
+const commonCredentialsSchema = () => joi_1.default.object({
+    model: joi_1.default.valid(`credentials`).required(),
+    sandbox: joi_1.default.bool().required(),
+    functions: joi_1.default.object({
+        check: joi_1.default.function().required(),
+    }).required(),
+});
+const oauthCredentialsSchema = () => joi_1.default.object({
+    type: joi_1.default.valid(`oauth`).required(),
+    functions: joi_1.default.object({
+        oauth: joi_1.default.function().required(),
+        connect: joi_1.default.function().required(),
+        refresh: joi_1.default.function().required(),
+        disconnect: joi_1.default.function().required(),
+    }).required(),
+})
+    .concat(commonCredentialsSchema())
+    .concat((0, commons_1.commonSchema)());
+exports.oauthCredentialsSchema = oauthCredentialsSchema;
+const sessionCredentialsSchema = () => joi_1.default.object({
+    type: joi_1.default.valid(`session`).required(),
+    functions: joi_1.default.object({
+        connect: joi_1.default.function().required(),
+    }).required(),
+})
+    .concat(commonCredentialsSchema())
+    .concat((0, commons_1.commonSchema)());
+exports.sessionCredentialsSchema = sessionCredentialsSchema;
+const staticCredentialsSchema = () => joi_1.default.object({
+    type: joi_1.default.valid(`static`).required(),
+    fields: (0, fields_1.fieldsSchema)()
+        .required()
+        .min(1),
+})
+    .concat(commonCredentialsSchema())
+    .concat((0, commons_1.commonSchema)());
+exports.staticCredentialsSchema = staticCredentialsSchema;
+const credentialsSchema = () => joi_1.default.alternatives(exports.oauthCredentialsSchema, exports.staticCredentialsSchema, exports.sessionCredentialsSchema);
+exports.credentialsSchema = credentialsSchema;

package/dist/entities/events.d.ts

@@ -0,0 +1,131 @@
+import { Request } from "express";
+import Joi from "joi";
+import { Field } from "../minified-utils/fields";
+import { Common, CoreConfig, CoreFunction } from "./commons";
+type CommonConnectableEvent<Keys extends string = string> = {
+    key: Keys;
+};
+type DefaultConnectableEvent<Keys extends string = string> = CommonConnectableEvent<Keys> & {
+    default: true;
+};
+type ErrorConnectableEvent<Keys extends string = string> = CommonConnectableEvent<Keys> & {
+    error: true;
+};
+type AdditionalConnectableEvent<Keys extends string = string> = CommonConnectableEvent<Keys> & {};
+export type ConnectableEvent<Keys extends string = string> = DefaultConnectableEvent<Keys> | ErrorConnectableEvent<Keys> | AdditionalConnectableEvent<Keys>;
+type EventConfig = Pick<CoreConfig, `credentials` | `outputs`> & {
+    flags?: {
+        inputs?: string[];
+        outputs: string[];
+    };
+};
+type CommonEvents<Config extends EventConfig = {}> = Common<Config> & {
+    model: `event`;
+    categories: string[];
+    credentials: string[];
+    sandbox: boolean;
+    fields: Field[];
+    examples: EventConfig[`outputs`][];
+};
+export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+    type: `trigger`;
+    immediate: true;
+    outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>];
+    functions: {
+        mount?: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: {
+                fields: Record<string, any>;
+            };
+            outputs: {
+                done: boolean;
+            };
+        }>;
+        unmount?: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: {
+                fields: Record<string, any>;
+            };
+            outputs: {
+                done: boolean;
+            };
+        }>;
+        handle: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: {
+                fields: Record<string, any>;
+                request: Request;
+            };
+            outputs: {
+                records: Config[`outputs`][];
+                flags: Partial<Record<Config[`flags`][`outputs`][number], true>>;
+            };
+        }>;
+        fire?: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: {
+                fields: Record<string, any>;
+            };
+            outputs: {
+                done: boolean;
+            };
+        }>;
+        poll?: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: {
+                fields: Record<string, any>;
+                last_schedule?: string;
+                limit?: number;
+            };
+            outputs: {
+                records: Config[`outputs`][];
+                flags: Partial<Record<Config[`flags`][`outputs`][number], true>>;
+            };
+        }>;
+    };
+};
+export type ScheduledTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+    type: `trigger`;
+    immediate: false;
+    outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>];
+    functions: {
+        poll: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: {
+                fields: Record<string, any>;
+                last_schedule?: string;
+                limit?: number;
+            };
+            outputs: {
+                records: Config[`outputs`][];
+                flags: Partial<Record<Config[`flags`][`outputs`][number], true>>;
+            };
+        }>;
+    };
+};
+export type Trigger<Config extends EventConfig = {}> = ImmediateTrigger<Config> | ScheduledTrigger<Config>;
+export type Action<Config extends EventConfig = {}> = CommonEvents<Config> & {
+    type: `action`;
+    inputs: [DefaultConnectableEvent<Config[`flags`][`inputs`][number]>, ...AdditionalConnectableEvent<Config[`flags`][`inputs`][number]>[]];
+    outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>, ...(AdditionalConnectableEvent<Config[`flags`][`outputs`][number]> | ErrorConnectableEvent<Config[`flags`][`outputs`][number]>)[]];
+    functions: {
+        execute: CoreFunction<{
+            credentials: Config[`credentials`];
+            inputs: {
+                fields: Record<string, any>;
+                flags: Partial<Record<Config[`flags`][`inputs`][number], true>>;
+            };
+            outputs: {
+                output: Config[`outputs`];
+                flags: Partial<Record<Config[`flags`][`outputs`][number], true>>;
+            };
+        }>;
+    };
+};
+export type Event<Config extends EventConfig = {}> = Action<Config> | Trigger<Config>;
+export declare const scheduledTriggerSchema: () => Joi.ObjectSchema<any>;
+export declare const immediateTriggerSchema: () => Joi.ObjectSchema<any>;
+export declare const triggerSchema: () => Joi.AlternativesSchema<any>;
+export declare const actionSchema: () => Joi.ObjectSchema<any>;
+export declare const eventSchema: () => Joi.AlternativesSchema<any>;
+export {};

package/dist/entities/events.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventSchema = exports.actionSchema = exports.triggerSchema = exports.immediateTriggerSchema = exports.scheduledTriggerSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const fields_1 = require("../minified-utils/fields");
+const commons_1 = require("./commons");
+const commonConnectableEventSchema = () => joi_1.default.object({
+    key: joi_1.default.string().required(),
+});
+const defaultConnectableEventSchema = () => joi_1.default.object({
+    default: joi_1.default.valid(true).required(),
+})
+    .concat(commonConnectableEventSchema());
+const errorConnectableEventSchema = () => joi_1.default.object({
+    error: joi_1.default.valid(true).required(),
+})
+    .concat(commonConnectableEventSchema());
+const additionalConnectableEventSchema = () => joi_1.default.object({})
+    .concat(commonConnectableEventSchema());
+const commonEventsSchema = () => joi_1.default.object({
+    model: joi_1.default.valid(`event`).required(),
+    categories: joi_1.default.array().items(joi_1.default.string()).required(),
+    credentials: joi_1.default.array().items((0, commons_1.idSchema)().optional()).required().min(0),
+    sandbox: joi_1.default.bool().required(),
+    fields: (0, fields_1.fieldsSchema)().required(),
+    examples: joi_1.default.array(),
+});
+const scheduledTriggerSchema = () => joi_1.default.object({
+    type: joi_1.default.valid(`trigger`).required(),
+    immediate: joi_1.default.valid(false).required(),
+    outputs: joi_1.default.array()
+        .length(1)
+        .items(defaultConnectableEventSchema())
+        .required(),
+    functions: joi_1.default.object({
+        poll: joi_1.default.function().required(),
+    }).required(),
+})
+    .concat((0, commons_1.commonSchema)())
+    .concat(commonEventsSchema());
+exports.scheduledTriggerSchema = scheduledTriggerSchema;
+const immediateTriggerSchema = () => joi_1.default.object({
+    type: joi_1.default.valid(`trigger`).required(),
+    immediate: joi_1.default.valid(true).required(),
+    outputs: joi_1.default.array()
+        .items(defaultConnectableEventSchema())
+        .length(1)
+        .required(),
+    functions: joi_1.default.object({
+        mount: joi_1.default.function(),
+        unmount: joi_1.default.function(),
+        handle: joi_1.default.function().required(),
+        poll: joi_1.default.function(),
+    }).required(),
+})
+    .concat((0, commons_1.commonSchema)())
+    .concat(commonEventsSchema());
+exports.immediateTriggerSchema = immediateTriggerSchema;
+const triggerSchema = () => joi_1.default.alternatives((0, exports.scheduledTriggerSchema)(), (0, exports.immediateTriggerSchema)());
+exports.triggerSchema = triggerSchema;
+const actionSchema = () => joi_1.default.object({
+    type: joi_1.default.valid(`action`).required(),
+    inputs: joi_1.default.array()
+        .items(defaultConnectableEventSchema().required(), additionalConnectableEventSchema())
+        .min(1)
+        .required(),
+    outputs: joi_1.default.array()
+        .items(defaultConnectableEventSchema().required(), errorConnectableEventSchema().optional(), additionalConnectableEventSchema().optional())
+        .min(1)
+        .required(),
+    functions: joi_1.default.object({
+        execute: joi_1.default.function().required(),
+    }).required(),
+})
+    .concat((0, commons_1.commonSchema)())
+    .concat(commonEventsSchema());
+exports.actionSchema = actionSchema;
+const eventSchema = () => joi_1.default.alternatives((0, exports.triggerSchema)(), (0, exports.actionSchema)());
+exports.eventSchema = eventSchema;

package/dist/entities/provider.d.ts

@@ -0,0 +1,12 @@
+import Joi from "joi";
+import { Credentials } from "./credentials";
+import { Action, Trigger } from "./events";
+export type Provider = {
+    id: string;
+    model: `provider`;
+    categories: string[];
+    credentials: Record<string, Credentials>;
+    triggers: Record<string, Trigger>;
+    actions: Record<string, Action>;
+};
+export declare const providerSchema: () => Joi.ObjectSchema<any>;

package/dist/entities/provider.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const credentials_1 = require("./credentials");
+const events_1 = require("./events");
+const commons_1 = require("./commons");
+const providerSchema = () => joi_1.default.object({
+    id: (0, commons_1.idSchema)(),
+    model: joi_1.default.valid(`provider`).required(),
+    categories: joi_1.default.array().items(joi_1.default.string()).required(),
+    credentials: joi_1.default.object()
+        .pattern((0, commons_1.idSchema)(), (0, credentials_1.credentialsSchema)())
+        .required(),
+    triggers: joi_1.default.object()
+        .pattern((0, commons_1.idSchema)(), (0, events_1.triggerSchema)())
+        .required(),
+    actions: joi_1.default.object()
+        .pattern((0, commons_1.idSchema)(), (0, events_1.actionSchema)())
+        .required(),
+});
+exports.providerSchema = providerSchema;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Core, core } from './core';
+export { getCategories } from './entities/category';
+export { CoreFunction, idSchema } from './entities/commons';
+export { Credentials, OAuthCredentials, StaticCredentials, SessionCredentials, credentialsSchema, oauthCredentialsSchema, staticCredentialsSchema, sessionCredentialsSchema } from './entities/credentials';
+export { Action, Event, ImmediateTrigger, ScheduledTrigger, Trigger, actionSchema, eventSchema, immediateTriggerSchema, scheduledTriggerSchema, triggerSchema } from './entities/events';
+export { Provider, providerSchema } from './entities/provider';
+export { Field, SelectFieldChoice, ValidationResult, extract, fieldSchema, fieldsSchema, validate } from './minified-utils/fields';
+export { i18n, localizeFields, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localizeProperties = exports.localizeOutputs = exports.localizeInputs = exports.localizeFields = exports.i18n = exports.validate = exports.fieldsSchema = exports.fieldSchema = exports.extract = exports.providerSchema = exports.triggerSchema = exports.scheduledTriggerSchema = exports.immediateTriggerSchema = exports.eventSchema = exports.actionSchema = exports.sessionCredentialsSchema = exports.staticCredentialsSchema = exports.oauthCredentialsSchema = exports.credentialsSchema = exports.idSchema = exports.getCategories = exports.core = void 0;
+var core_1 = require("./core");
+Object.defineProperty(exports, "core", { enumerable: true, get: function () { return core_1.core; } });
+var category_1 = require("./entities/category");
+Object.defineProperty(exports, "getCategories", { enumerable: true, get: function () { return category_1.getCategories; } });
+var commons_1 = require("./entities/commons");
+Object.defineProperty(exports, "idSchema", { enumerable: true, get: function () { return commons_1.idSchema; } });
+var credentials_1 = require("./entities/credentials");
+Object.defineProperty(exports, "credentialsSchema", { enumerable: true, get: function () { return credentials_1.credentialsSchema; } });
+Object.defineProperty(exports, "oauthCredentialsSchema", { enumerable: true, get: function () { return credentials_1.oauthCredentialsSchema; } });
+Object.defineProperty(exports, "staticCredentialsSchema", { enumerable: true, get: function () { return credentials_1.staticCredentialsSchema; } });
+Object.defineProperty(exports, "sessionCredentialsSchema", { enumerable: true, get: function () { return credentials_1.sessionCredentialsSchema; } });
+var events_1 = require("./entities/events");
+Object.defineProperty(exports, "actionSchema", { enumerable: true, get: function () { return events_1.actionSchema; } });
+Object.defineProperty(exports, "eventSchema", { enumerable: true, get: function () { return events_1.eventSchema; } });
+Object.defineProperty(exports, "immediateTriggerSchema", { enumerable: true, get: function () { return events_1.immediateTriggerSchema; } });
+Object.defineProperty(exports, "scheduledTriggerSchema", { enumerable: true, get: function () { return events_1.scheduledTriggerSchema; } });
+Object.defineProperty(exports, "triggerSchema", { enumerable: true, get: function () { return events_1.triggerSchema; } });
+var provider_1 = require("./entities/provider");
+Object.defineProperty(exports, "providerSchema", { enumerable: true, get: function () { return provider_1.providerSchema; } });
+var fields_1 = require("./minified-utils/fields");
+Object.defineProperty(exports, "extract", { enumerable: true, get: function () { return fields_1.extract; } });
+Object.defineProperty(exports, "fieldSchema", { enumerable: true, get: function () { return fields_1.fieldSchema; } });
+Object.defineProperty(exports, "fieldsSchema", { enumerable: true, get: function () { return fields_1.fieldsSchema; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return fields_1.validate; } });
+var locales_1 = require("./minified-utils/locales");
+Object.defineProperty(exports, "i18n", { enumerable: true, get: function () { return locales_1.i18n; } });
+Object.defineProperty(exports, "localizeFields", { enumerable: true, get: function () { return locales_1.localizeFields; } });
+Object.defineProperty(exports, "localizeInputs", { enumerable: true, get: function () { return locales_1.localizeInputs; } });
+Object.defineProperty(exports, "localizeOutputs", { enumerable: true, get: function () { return locales_1.localizeOutputs; } });
+Object.defineProperty(exports, "localizeProperties", { enumerable: true, get: function () { return locales_1.localizeProperties; } });

package/dist/minified-utils/context.d.ts

@@ -0,0 +1,6 @@
+declare class Context {
+    constructor();
+    readonly resolve: (source: any, data: Record<string, any>) => any;
+}
+declare const context: Context;
+export default context;

package/dist/minified-utils/context.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const handlebars_1 = __importDefault(require("handlebars"));
+const lodash_1 = __importDefault(require("lodash"));
+class Context {
+    constructor() {
+        this.resolve = (source, data) => {
+            let isObject = false;
+            let unresolved;
+            if (lodash_1.default.isNull(source) || lodash_1.default.isUndefined(source)) {
+                return source;
+            }
+            if (lodash_1.default.isObject(source) || lodash_1.default.isArray(source)) {
+                isObject = true;
+                unresolved = JSON.stringify(source);
+            }
+            else if (typeof source === `string`) {
+                unresolved = source;
+            }
+            else {
+                return source;
+            }
+            if (!unresolved.includes(`{{`)) {
+                return source;
+            }
+            const template = handlebars_1.default.compile(unresolved);
+            const resolved = template(data);
+            return isObject ? JSON.parse(resolved) : resolved;
+        };
+        handlebars_1.default.registerHelper({
+            eq: (v1, v2) => v1 === v2,
+            ne: (v1, v2) => v1 !== v2,
+            lt: (v1, v2) => v1 < v2,
+            gt: (v1, v2) => v1 > v2,
+            lte: (v1, v2) => v1 <= v2,
+            gte: (v1, v2) => v1 >= v2,
+            and: (v1, v2) => v1 && v2,
+            or: (v1, v2) => v1 || v2,
+            "+": (v1, v2) => v1 + v2,
+            "-": (v1, v2) => v1 - v2,
+            "*": (v1, v2) => v1 * v2,
+            "/": (v1, v2) => v1 / v2,
+            "sum": (v1, v2) => v1 + v2,
+            "subtract": (v1, v2) => v1 - v2,
+            "multiply": (v1, v2) => v1 * v2,
+            "divide": (v1, v2) => v1 / v2,
+            "abs": (v1) => Math.abs(v1),
+        });
+    }
+}
+const context = new Context();
+exports.default = context;

package/dist/minified-utils/env.d.ts

@@ -0,0 +1,13 @@
+type ReadOptions = {
+    create?: boolean;
+};
+export declare class Env {
+    private readonly filepath;
+    private readonly env;
+    private readonly getEnv;
+    constructor(root: string);
+    readonly read: (name: string, options?: ReadOptions) => Promise<string>;
+    readonly write: (name: string, value: string) => Promise<void>;
+    private readonly prompt;
+}
+export {};