@accordproject/template-engine 2.6.7 → 2.7.1

package/dist/index.d.ts

@@ -57,17 +57,17 @@ interface IClause extends IAsset {
    clauseId: string;
 }
 
-interface TriggerResponse<S extends IState> extends EngineResponse<S> {
+interface TriggerResponse$1<S extends IState = IState> extends EngineResponse<S> {
     result: IResponse;
 }
 
-interface InitResponse<S extends IState> extends EngineResponse<S> {}
+interface InitResponse$1<S extends IState> extends EngineResponse<S> {}
 
 type TemplateData$1 = IContract|IClause;
 
 declare abstract class TemplateLogic<T extends TemplateData$1, S extends IState = IState> {
-    abstract trigger(data: T, request: IRequest, state:S) : Promise<TriggerResponse<S>>;
-    init(data: T) : Promise<InitResponse<S>|undefined>;
+    abstract trigger(data: T, request: IRequest, state:S) : Promise<TriggerResponse$1<S>>;
+    init(data: T) : Promise<InitResponse$1<S>|undefined>;
 }
 
 type TemplateData = Record<string, unknown>;
@@ -116,6 +116,17 @@ declare class TemplateMarkInterpreter {
     generate(templateMark: object, data: TemplateData, options?: GenerationOptions): Promise<any>;
 }
 
+type State = object;
+type Response = object;
+type Event = object;
+type TriggerResponse = {
+    result: Response;
+    state: State;
+    events: Event[];
+};
+type InitResponse = {
+    state: State;
+};
 /**
  * A template archive processor: can draft content using the
  * templatemark for the archive and trigger the logic of the archive
@@ -144,7 +155,14 @@ declare class TemplateArchiveProcessor {
      * @param {[number]} utcOffset - the UTC offer, defaults to zero
      * @returns {Promise} the response and any events
      */
-    trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number): Promise<any>;
+    trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number): Promise<TriggerResponse>;
+    /**
+     * Init the logic of a template
+     * @param {[string]} currentTime - the current time, defaults to now
+     * @param {[number]} utcOffset - the UTC offer, defaults to zero
+     * @returns {Promise} the response and any events
+     */
+    init(data: any, currentTime?: string, utcOffset?: number): Promise<InitResponse>;
 }
 
 declare function ensureDirSync(path: string): void;

package/dist/index.js

@@ -327,7 +327,7 @@ type GenerationOptions = {
 
 const DAYJS_BASE64 = "/// <reference path="./locale/index.d.ts" />

export = dayjs;

declare function dayjs (date?: dayjs.ConfigType): dayjs.Dayjs

declare function dayjs (date?: dayjs.ConfigType, format?: dayjs.OptionType, strict?: boolean): dayjs.Dayjs

declare function dayjs (date?: dayjs.ConfigType, format?: dayjs.OptionType, locale?: string, strict?: boolean): dayjs.Dayjs

declare namespace dayjs {
  interface ConfigTypeMap {
    default: string | number | Date | Dayjs | null | undefined
  }

  export type ConfigType = ConfigTypeMap[keyof ConfigTypeMap]

  export interface FormatObject { locale?: string, format?: string, utc?: boolean }

  export type OptionType = FormatObject | string | string[]

  export type UnitTypeShort = 'd' | 'D' | 'M' | 'y' | 'h' | 'm' | 's' | 'ms'

  export type UnitTypeLong = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year' | 'date'

  export type UnitTypeLongPlural = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'months' | 'years' | 'dates'
  
  export type UnitType = UnitTypeLong | UnitTypeLongPlural | UnitTypeShort;

  export type OpUnitType = UnitType | "week" | "weeks" | 'w';
  export type QUnitType = UnitType | "quarter" | "quarters" | 'Q';
  export type ManipulateType = Exclude<OpUnitType, 'date' | 'dates'>;
  class Dayjs {
    constructor (config?: ConfigType)
    /**
     * All Day.js objects are immutable. Still, `dayjs#clone` can create a clone of the current object if you need one.
     * ```
     * dayjs().clone()// => Dayjs
     * dayjs(dayjs('2019-01-25')) // passing a Dayjs object to a constructor will also clone it
     * ```
     * Docs: https://day.js.org/docs/en/parse/dayjs-clone
     */
    clone(): Dayjs
    /**
     * This returns a `boolean` indicating whether the Day.js object contains a valid date or not.
     * ```
     * dayjs().isValid()// => boolean
     * ```
     * Docs: https://day.js.org/docs/en/parse/is-valid
     */
    isValid(): boolean
    /**
     * Get the year.
     * ```
     * dayjs().year()// => 2020
     * ```
     * Docs: https://day.js.org/docs/en/get-set/year
     */
    year(): number
    /**
     * Set the year.
     * ```
     * dayjs().year(2000)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/year
     */
    year(value: number): Dayjs
    /**
     * Get the month.
     *
     * Months are zero indexed, so January is month 0.
     * ```
     * dayjs().month()// => 0-11
     * ```
     * Docs: https://day.js.org/docs/en/get-set/month
     */
    month(): number
    /**
     * Set the month.
     *
     * Months are zero indexed, so January is month 0.
     *
     * Accepts numbers from 0 to 11. If the range is exceeded, it will bubble up to the next year.
     * ```
     * dayjs().month(0)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/month
     */
    month(value: number): Dayjs
    /**
     * Get the date of the month.
     * ```
     * dayjs().date()// => 1-31
     * ```
     * Docs: https://day.js.org/docs/en/get-set/date
     */
    date(): number
    /**
     * Set the date of the month.
     *
     * Accepts numbers from 1 to 31. If the range is exceeded, it will bubble up to the next months.
     * ```
     * dayjs().date(1)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/date
     */
    date(value: number): Dayjs
    /**
     * Get the day of the week.
     *
     * Returns numbers from 0 (Sunday) to 6 (Saturday).
     * ```
     * dayjs().day()// 0-6
     * ```
     * Docs: https://day.js.org/docs/en/get-set/day
     */
    day(): 0 | 1 | 2 | 3 | 4 | 5 | 6
    /**
     * Set the day of the week.
     *
     * Accepts numbers from 0 (Sunday) to 6 (Saturday). If the range is exceeded, it will bubble up to next weeks.
     * ```
     * dayjs().day(0)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/day
     */
    day(value: number): Dayjs
    /**
     * Get the hour.
     * ```
     * dayjs().hour()// => 0-23
     * ```
     * Docs: https://day.js.org/docs/en/get-set/hour
     */
    hour(): number
    /**
     * Set the hour.
     *
     * Accepts numbers from 0 to 23. If the range is exceeded, it will bubble up to the next day.
     * ```
     * dayjs().hour(12)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/hour
     */
    hour(value: number): Dayjs
    /**
     * Get the minutes.
     * ```
     * dayjs().minute()// => 0-59
     * ```
     * Docs: https://day.js.org/docs/en/get-set/minute
     */
    minute(): number
    /**
     * Set the minutes.
     *
     * Accepts numbers from 0 to 59. If the range is exceeded, it will bubble up to the next hour.
     * ```
     * dayjs().minute(59)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/minute
     */
    minute(value: number): Dayjs
    /**
     * Get the seconds.
     * ```
     * dayjs().second()// => 0-59
     * ```
     * Docs: https://day.js.org/docs/en/get-set/second
     */
    second(): number
    /**
     * Set the seconds.
     *
     * Accepts numbers from 0 to 59. If the range is exceeded, it will bubble up to the next minutes.
     * ```
     * dayjs().second(1)// Dayjs
     * ```
     */
    second(value: number): Dayjs
    /**
     * Get the milliseconds.
     * ```
     * dayjs().millisecond()// => 0-999
     * ```
     * Docs: https://day.js.org/docs/en/get-set/millisecond
     */
    millisecond(): number
    /**
     * Set the milliseconds.
     *
     * Accepts numbers from 0 to 999. If the range is exceeded, it will bubble up to the next seconds.
     * ```
     * dayjs().millisecond(1)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/millisecond
     */
    millisecond(value: number): Dayjs
    /**
     * Generic setter, accepting unit as first argument, and value as second, returns a new instance with the applied changes.
     *
     * In general:
     * ```
     * dayjs().set(unit, value) === dayjs()[unit](value)
     * ```
     * Units are case insensitive, and support plural and short forms.
     * ```
     * dayjs().set('date', 1)
     * dayjs().set('month', 3) // April
     * dayjs().set('second', 30)
     * ```
     * Docs: https://day.js.org/docs/en/get-set/set
     */
    set(unit: UnitType, value: number): Dayjs
    /**
     * String getter, returns the corresponding information getting from Day.js object.
     *
     * In general:
     * ```
     * dayjs().get(unit) === dayjs()[unit]()
     * ```
     * Units are case insensitive, and support plural and short forms.
     * ```
     * dayjs().get('year')
     * dayjs().get('month') // start 0
     * dayjs().get('date')
     * ```
     * Docs: https://day.js.org/docs/en/get-set/get
     */
    get(unit: UnitType): number
    /**
     * Returns a cloned Day.js object with a specified amount of time added.
     * ```
     * dayjs().add(7, 'day')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/add
     */
    add(value: number, unit?: ManipulateType): Dayjs
    /**
     * Returns a cloned Day.js object with a specified amount of time subtracted.
     * ```
     * dayjs().subtract(7, 'year')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/subtract
     */
    subtract(value: number, unit?: ManipulateType): Dayjs
    /**
     * Returns a cloned Day.js object and set it to the start of a unit of time.
     * ```
     * dayjs().startOf('year')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/start-of
     */
    startOf(unit: OpUnitType): Dayjs
    /**
     * Returns a cloned Day.js object and set it to the end of a unit of time.
     * ```
     * dayjs().endOf('month')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/end-of
     */
    endOf(unit: OpUnitType): Dayjs
    /**
     * Get the formatted date according to the string of tokens passed in.
     *
     * To escape characters, wrap them in square brackets (e.g. [MM]).
     * ```
     * dayjs().format()// => current date in ISO8601, without fraction seconds e.g. '2020-04-02T08:02:17-05:00'
     * dayjs('2019-01-25').format('[YYYYescape] YYYY-MM-DDTHH:mm:ssZ[Z]')// 'YYYYescape 2019-01-25T00:00:00-02:00Z'
     * dayjs('2019-01-25').format('DD/MM/YYYY') // '25/01/2019'
     * ```
     * Docs: https://day.js.org/docs/en/display/format
     */
    format(template?: string): string
    /**
     * This indicates the difference between two date-time in the specified unit.
     *
     * To get the difference in milliseconds, use `dayjs#diff`
     * ```
     * const date1 = dayjs('2019-01-25')
     * const date2 = dayjs('2018-06-05')
     * date1.diff(date2) // 20214000000 default milliseconds
     * date1.diff() // milliseconds to current time
     * ```
     *
     * To get the difference in another unit of measurement, pass that measurement as the second argument.
     * ```
     * const date1 = dayjs('2019-01-25')
     * date1.diff('2018-06-05', 'month') // 7
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/display/difference
     */
    diff(date?: ConfigType, unit?: QUnitType | OpUnitType, float?: boolean): number
    /**
     * This returns the number of **milliseconds** since the Unix Epoch of the Day.js object.
     * ```
     * dayjs('2019-01-25').valueOf() // 1548381600000
     * +dayjs(1548381600000) // 1548381600000
     * ```
     * To get a Unix timestamp (the number of seconds since the epoch) from a Day.js object, you should use Unix Timestamp `dayjs#unix()`.
     *
     * Docs: https://day.js.org/docs/en/display/unix-timestamp-milliseconds
     */
    valueOf(): number
    /**
     * This returns the Unix timestamp (the number of **seconds** since the Unix Epoch) of the Day.js object.
     * ```
     * dayjs('2019-01-25').unix() // 1548381600
     * ```
     * This value is floored to the nearest second, and does not include a milliseconds component.
     *
     * Docs: https://day.js.org/docs/en/display/unix-timestamp
     */
    unix(): number
    /**
     * Get the number of days in the current month.
     * ```
     * dayjs('2019-01-25').daysInMonth() // 31
     * ```
     * Docs: https://day.js.org/docs/en/display/days-in-month
     */
    daysInMonth(): number
    /**
     * To get a copy of the native `Date` object parsed from the Day.js object use `dayjs#toDate`.
     * ```
     * dayjs('2019-01-25').toDate()// => Date
     * ```
     */
    toDate(): Date
    /**
     * To serialize as an ISO 8601 string.
     * ```
     * dayjs('2019-01-25').toJSON() // '2019-01-25T02:00:00.000Z'
     * ```
     * Docs: https://day.js.org/docs/en/display/as-json
     */
    toJSON(): string
    /**
     * To format as an ISO 8601 string.
     * ```
     * dayjs('2019-01-25').toISOString() // '2019-01-25T02:00:00.000Z'
     * ```
     * Docs: https://day.js.org/docs/en/display/as-iso-string
     */
    toISOString(): string
    /**
     * Returns a string representation of the date.
     * ```
     * dayjs('2019-01-25').toString() // 'Fri, 25 Jan 2019 02:00:00 GMT'
     * ```
     * Docs: https://day.js.org/docs/en/display/as-string
     */
    toString(): string
    /**
     * Get the UTC offset in minutes.
     * ```
     * dayjs().utcOffset()
     * ```
     * Docs: https://day.js.org/docs/en/manipulate/utc-offset
     */
    utcOffset(): number
    /**
     * This indicates whether the Day.js object is before the other supplied date-time.
     * ```
     * dayjs().isBefore(dayjs('2011-01-01')) // default milliseconds
     * ```
     * If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.
     * ```
     * dayjs().isBefore('2011-01-01', 'year')// => boolean
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/query/is-before
     */
    isBefore(date?: ConfigType, unit?: OpUnitType): boolean
    /**
     * This indicates whether the Day.js object is the same as the other supplied date-time.
     * ```
     * dayjs().isSame(dayjs('2011-01-01')) // default milliseconds
     * ```
     * If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.
     * ```
     * dayjs().isSame('2011-01-01', 'year')// => boolean
     * ```
     * Docs: https://day.js.org/docs/en/query/is-same
     */
    isSame(date?: ConfigType, unit?: OpUnitType): boolean
    /**
     * This indicates whether the Day.js object is after the other supplied date-time.
     * ```
     * dayjs().isAfter(dayjs('2011-01-01')) // default milliseconds
     * ```
     * If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.
     * ```
     * dayjs().isAfter('2011-01-01', 'year')// => boolean
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/query/is-after
     */
    isAfter(date?: ConfigType, unit?: OpUnitType): boolean

    locale(): string

    locale(preset: string | ILocale, object?: Partial<ILocale>): Dayjs
  }

  export type PluginFunc<T = unknown> = (option: T, c: typeof Dayjs, d: typeof dayjs) => void

  export function extend<T = unknown>(plugin: PluginFunc<T>, option?: T): Dayjs

  export function locale(preset?: string | ILocale, object?: Partial<ILocale>, isLocal?: boolean): string

  export function isDayjs(d: any): d is Dayjs

  export function unix(t: number): Dayjs

  const Ls : { [key: string] :  ILocale }
}
";
 const JSONPATH_BASE64 = "dHlwZSBQYXRoQ29tcG9uZW50ID0gc3RyaW5nIHwgbnVtYmVyOwoKLyoqCiAqIEZpbmQgZWxlbWVudHMgaW4gYG9iamAgbWF0Y2hpbmcgYHBhdGhFeHByZXNzaW9uYC4gUmV0dXJucyBhbiBhcnJheSBvZiBlbGVtZW50cyB0aGF0CiAqIHNhdGlzZnkgdGhlIHByb3ZpZGVkIEpTT05QYXRoIGV4cHJlc3Npb24sb3IgYW4gZW1wdHkgYXJyYXkgaWYgbm9uZSB3ZXJlIG1hdGNoZWQuCiAqIFJldHVybnMgb25seSBmaXJzdCBgY291bnRgIGVsZW1lbnRzIGlmIHNwZWNpZmllZC4KICovCmV4cG9ydCBkZWNsYXJlIGZ1bmN0aW9uIHF1ZXJ5KG9iajogYW55LCBwYXRoRXhwcmVzc2lvbjogc3RyaW5nLCBjb3VudD86IG51bWJlcik6IGFueVtdOwoKLyoqCiAqIEZpbmQgcGF0aHMgdG8gZWxlbWVudHMgaW4gYG9iamAgbWF0Y2hpbmcgYHBhdGhFeHByZXNzaW9uYC4gUmV0dXJucyBhbiBhcnJheSBvZgogKiBlbGVtZW50IHBhdGhzIHRoYXQgc2F0aXNmeSB0aGUgcHJvdmlkZWQgSlNPTlBhdGggZXhwcmVzc2lvbi4gRWFjaCBwYXRoIGlzIGl0c2VsZiBhbgogKiBhcnJheSBvZiBrZXlzIHJlcHJlc2VudGluZyB0aGUgbG9jYXRpb24gd2l0aGluIGBvYmpgIG9mIHRoZSBtYXRjaGluZyBlbGVtZW50LiBSZXR1cm5zCiAqIG9ubHkgZmlyc3QgYGNvdW50YCBwYXRocyBpZiBzcGVjaWZpZWQuCiAqLwpleHBvcnQgZGVjbGFyZSBmdW5jdGlvbiBwYXRocyhvYmo6IGFueSwgcGF0aEV4cHJlc3Npb246IHN0cmluZywgY291bnQ/OiBudW1iZXIpOiBQYXRoQ29tcG9uZW50W11bXTsKCi8qKgogKiBGaW5kIGVsZW1lbnRzIGFuZCB0aGVpciBjb3JyZXNwb25kaW5nIHBhdGhzIGluIGBvYmpgIG1hdGNoaW5nIGBwYXRoRXhwcmVzc2lvbmAuCiAqIFJldHVybnMgYW4gYXJyYXkgb2Ygbm9kZSBvYmplY3RzIHdoZXJlIGVhY2ggbm9kZSBoYXMgYSBgcGF0aGAgY29udGFpbmluZyBhbiBhcnJheSBvZgogKiBrZXlzIHJlcHJlc2VudGluZyB0aGUgbG9jYXRpb24gd2l0aGluIGBvYmpgLCBhbmQgYSBgdmFsdWVgIHBvaW50aW5nIHRvIHRoZSBtYXRjaGVkCiAqIGVsZW1lbnQuIFJldHVybnMgb25seSBmaXJzdCBgY291bnRgIG5vZGVzIGlmIHNwZWNpZmllZC4KICovCmV4cG9ydCBkZWNsYXJlIGZ1bmN0aW9uIG5vZGVzKAogICAgb2JqOiBhbnksCiAgICBwYXRoRXhwcmVzc2lvbjogc3RyaW5nLAogICAgY291bnQ/OiBudW1iZXIsCik6IEFycmF5PHsgcGF0aDogUGF0aENvbXBvbmVudFtdOyB2YWx1ZTogYW55IH0+OwoKLyoqCiAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSBmaXJzdCBlbGVtZW50IG1hdGNoaW5nIGBwYXRoRXhwcmVzc2lvbmAuIElmIGBuZXdWYWx1ZWAgaXMKICogcHJvdmlkZWQsIHNldHMgdGhlIHZhbHVlIG9mIHRoZSBmaXJzdCBtYXRjaGluZyBlbGVtZW50IGFuZCByZXR1cm5zIHRoZSBuZXcgdmFsdWUuCiAqLwpleHBvcnQgZGVjbGFyZSBmdW5jdGlvbiB2YWx1ZShvYmo6IGFueSwgcGF0aEV4cHJlc3Npb246IHN0cmluZyk6IGFueTsKZXhwb3J0IGRlY2xhcmUgZnVuY3Rpb24gdmFsdWU8VD4ob2JqOiBhbnksIHBhdGhFeHByZXNzaW9uOiBzdHJpbmcsIG5ld1ZhbHVlOiBUKTogVDsKCi8qKgogKiBSZXR1cm5zIHRoZSBwYXJlbnQgb2YgdGhlIGZpcnN0IG1hdGNoaW5nIGVsZW1lbnQuCiAqLwpleHBvcnQgZGVjbGFyZSBmdW5jdGlvbiBwYXJlbnQob2JqOiBhbnksIHBhdGhFeHByZXNzaW9uOiBzdHJpbmcpOiBhbnk7CgovKioKICogUnVucyB0aGUgc3VwcGxpZWQgZnVuY3Rpb24gYGZuYCBvbiBlYWNoIG1hdGNoaW5nIGVsZW1lbnQsIGFuZCByZXBsYWNlcyBlYWNoCiAqIG1hdGNoaW5nIGVsZW1lbnQgd2l0aCB0aGUgcmV0dXJuIHZhbHVlIGZyb20gdGhlIGZ1bmN0aW9uLiBUaGUgZnVuY3Rpb24gYWNjZXB0cyB0aGUKICogdmFsdWUgb2YgdGhlIG1hdGNoaW5nIGVsZW1lbnQgYXMgaXRzIG9ubHkgcGFyYW1ldGVyLiBSZXR1cm5zIG1hdGNoaW5nIG5vZGVzIHdpdGgKICogdGhlaXIgdXBkYXRlZCB2YWx1ZXMuCiAqLwpleHBvcnQgZGVjbGFyZSBmdW5jdGlvbiBhcHBseSgKICAgIG9iajogYW55LAogICAgcGF0aEV4cHJlc3Npb246IHN0cmluZywKICAgIGZuOiAoeDogYW55KSA9PiBhbnksCik6IEFycmF5PHsgcGF0aDogUGF0aENvbXBvbmVudFtdOyB2YWx1ZTogYW55IH0+OwoKLyoqCiAqIFBhcnNlIHRoZSBwcm92aWRlZCBKU09OUGF0aCBleHByZXNzaW9uIGludG8gcGF0aCBjb21wb25lbnRzIGFuZCB0aGVpciBhc3NvY2lhdGVkCiAqIG9wZXJhdGlvbnMuCiAqLwpleHBvcnQgZGVjbGFyZSBmdW5jdGlvbiBwYXJzZShwYXRoRXhwcmVzc2lvbjogc3RyaW5nKTogYW55W107CgovKioKICogUmV0dXJucyBhIHBhdGggZXhwcmVzc2lvbiBpbiBzdHJpbmcgZm9ybSwgZ2l2ZW4gYSBwYXRoLiBUaGUgc3VwcGxpZWQgcGF0aCBtYXkgZWl0aGVyCiAqIGJlIGEgZmxhdCBhcnJheSBvZiBrZXlzLCBhcyByZXR1cm5lZCBieSBganAubm9kZXNgIGZvciBleGFtcGxlLCBvciBtYXkgYWx0ZXJuYXRpdmVseSBiZSBhCiAqIGZ1bGx5IHBhcnNlZCBwYXRoIGV4cHJlc3Npb24gaW4gdGhlIGZvcm0gb2YgYW4gYXJyYXkgb2YgcGF0aCBjb21wb25lbnRzIGFzIHJldHVybmVkCiAqIGJ5IGBqcC5wYXJzZWAuCiAqLwpleHBvcnQgZGVjbGFyZSBmdW5jdGlvbiBzdHJpbmdpZnkocGF0aDogUGF0aENvbXBvbmVudFtdKTogc3RyaW5nOwoKZXhwb3J0IGFzIG5hbWVzcGFjZSBqc29ucGF0aDsK";
-const SMART_LEGAL_CONTRACT_BASE64 = "LyoKICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlICJMaWNlbnNlIik7CiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS4KICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0CiAqCiAqIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMAogKgogKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlCiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuICJBUyBJUyIgQkFTSVMsCiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLgogKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kCiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLgogKi8KCi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1vYmplY3QtdHlwZSAqLwoKLy8gd2UgZHVwbGljYXRlIHRoZXNlIGludGVyZmFjZXMgaGVyZSB0byBhdm9pZCBpbXBvcnRzIGludG8gdGhlIHJ1bnRpbWUKaW50ZXJmYWNlIElDb25jZXB0IHsKICAgICRjbGFzczogc3RyaW5nOwogfQoKaW50ZXJmYWNlIElUcmFuc2FjdGlvbiBleHRlbmRzIElDb25jZXB0IHsKICAgICR0aW1lc3RhbXA6IERhdGU7CiB9CgppbnRlcmZhY2UgSUV2ZW50IGV4dGVuZHMgSUNvbmNlcHQgewogICAkdGltZXN0YW1wOiBEYXRlOwp9CgppbnRlcmZhY2UgSVN0YXRlIHsKICAgICRpZGVudGlmaWVyOiBzdHJpbmc7Cn0KCmludGVyZmFjZSBFbmdpbmVSZXNwb25zZTxTIGV4dGVuZHMgSVN0YXRlPiB7CiAgICBzdGF0ZT86IFM7CiAgICBldmVudHM/OiBBcnJheTxJRXZlbnQ+Cn0KCmludGVyZmFjZSBJUmVxdWVzdCBleHRlbmRzIElUcmFuc2FjdGlvbiB7Cn0KCmludGVyZmFjZSBJUmVzcG9uc2UgZXh0ZW5kcyBJVHJhbnNhY3Rpb24gewp9CgppbnRlcmZhY2UgSUFzc2V0IGV4dGVuZHMgSUNvbmNlcHQgewogICAkaWRlbnRpZmllcjogc3RyaW5nOwp9CgppbnRlcmZhY2UgSUNvbnRyYWN0IGV4dGVuZHMgSUFzc2V0IHsKICAgY29udHJhY3RJZDogc3RyaW5nOwp9CgppbnRlcmZhY2UgSUNsYXVzZSBleHRlbmRzIElBc3NldCB7CiAgIGNsYXVzZUlkOiBzdHJpbmc7Cn0KCmludGVyZmFjZSBUcmlnZ2VyUmVzcG9uc2U8UyBleHRlbmRzIElTdGF0ZT4gZXh0ZW5kcyBFbmdpbmVSZXNwb25zZTxTPiB7CiAgICByZXN1bHQ6IElSZXNwb25zZTsKfQoKaW50ZXJmYWNlIEluaXRSZXNwb25zZTxTIGV4dGVuZHMgSVN0YXRlPiBleHRlbmRzIEVuZ2luZVJlc3BvbnNlPFM+IHt9Cgp0eXBlIFRlbXBsYXRlRGF0YSA9IElDb250cmFjdHxJQ2xhdXNlOwoKZXhwb3J0IGFic3RyYWN0IGNsYXNzIFRlbXBsYXRlTG9naWM8VCBleHRlbmRzIFRlbXBsYXRlRGF0YSwgUyBleHRlbmRzIElTdGF0ZSA9IElTdGF0ZT4gewogICAgYWJzdHJhY3QgdHJpZ2dlcihkYXRhOiBULCByZXF1ZXN0OiBJUmVxdWVzdCwgc3RhdGU6UykgOiBQcm9taXNlPFRyaWdnZXJSZXNwb25zZTxTPj47CiAgICBpbml0KGRhdGE6IFQpIDogUHJvbWlzZTxJbml0UmVzcG9uc2U8Uz58dW5kZWZpbmVkPjsKfQo=";
+const SMART_LEGAL_CONTRACT_BASE64 = "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";
 
 const TYPESCRIPT_URL = process.env.TYPESCRIPT_URL ? process.env.TYPESCRIPT_URL : "https://cdn.jsdelivr.net/npm/typescript@4.9.4/+esm";
 const SCRIPT_TARGET = 9;
@@ -508,7 +508,10 @@ class JavaScriptEvaluator {
           const dataUri = "data:text/javascript;base64," + btoa(request.code);
           dynamicImport(dataUri).then((templateLogicConstructor) => {
             const instance = new templateLogicConstructor();
-            result = instance.trigger(...request.arguments);
+            if (!request.functionName) {
+              throw new Error("No function name specified for template logic");
+            }
+            result = instance[request.functionName](...request.arguments);
             const end = (/* @__PURE__ */ new Date()).getTime();
             resolve({ result, elapsed: end - start });
           }).catch((err) => {
@@ -729,6 +732,35 @@ async function evaluateUserCode(clauseLibrary, templateMark, data, options) {
   }
   return result;
 }
+async function generateOptionalBlocks(modelManager, clauseLibrary, templateMark, data, options) {
+  const result = {};
+  const paths = traverse(templateMark).paths();
+  for (let n = 0; n < paths.length; n++) {
+    const thisPath = paths[n];
+    const context = traverse(templateMark).get(thisPath);
+    if (typeof context === "object" && context.$class && typeof context.$class === "string") {
+      const nodeClass = context.$class;
+      if (OPTIONAL_DEFINITION_RE.test(nodeClass)) {
+        const path = getJsonPath(templateMark, context, thisPath);
+        const variableValues = jp.query(data, path, 1);
+        if (variableValues.length > 0) {
+          const optionalPropertyValue = variableValues[0];
+          if (context.whenSome && context.whenSome.length > 0) {
+            const whenSomeParagraph = {
+              $class: "org.accordproject.commonmark@0.5.0.Paragraph",
+              nodes: context.whenSome
+            };
+            const subResult = await generateAgreement(modelManager, clauseLibrary, whenSomeParagraph, optionalPropertyValue, options);
+            result[thisPath.join("/")] = subResult.nodes ? subResult.nodes : [];
+          } else {
+            result[thisPath.join("/")] = [];
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
 async function generateRecursiveBlocks(modelManager, clauseLibrary, templateMark, data, nodeRegExp, childNodeClass, options) {
   const result = {};
   const paths = traverse(templateMark).paths();
@@ -769,6 +801,7 @@ async function generateAgreement(modelManager, clauseLibrary, templateMark, data
   const userCodeResults = await evaluateUserCode(clauseLibrary, templateMark, data, options);
   const listBlockResults = await generateRecursiveBlocks(modelManager, clauseLibrary, templateMark, data, LISTBLOCK_DEFINITION_RE, `${markdownCommon.CommonMarkModel.NAMESPACE}.Item`, options);
   const foreachBlockResults = await generateRecursiveBlocks(modelManager, clauseLibrary, templateMark, data, FOREACH_DEFINITION_RE, `${markdownCommon.CommonMarkModel.NAMESPACE}.Paragraph`, options);
+  const optionalBlockResults = await generateOptionalBlocks(modelManager, clauseLibrary, templateMark, data, options);
   return traverse(templateMark).map(function(context) {
     let stopHere = false;
     if (typeof context === "object" && context.$class && typeof context.$class === "string") {
@@ -894,14 +927,21 @@ async function generateAgreement(modelManager, clauseLibrary, templateMark, data
           if (variableValues.length === 1) {
             context.hasSome = true;
             context.whenNone = [];
+            if (optionalBlockResults[this.path.join("/")]) {
+              context.nodes = optionalBlockResults[this.path.join("/")];
+              context.whenSome = [];
+              stopHere = true;
+            } else {
+              context.nodes = context.whenSome;
+            }
           } else {
             throw new Error(`Multiple values found for path '${path}' in data ${data}.`);
           }
         } else {
           context.hasSome = false;
           context.whenSome = [];
+          context.nodes = context.whenNone;
         }
-        context.nodes = context.hasSome ? context.whenSome : context.whenNone;
       }
     }
     this.update(context, stopHere);
@@ -1057,14 +1097,61 @@ class TemplateArchiveProcessor {
       const evalResponse = await evaluator.evalDangerously({
         templateLogic: true,
         verbose: false,
+        functionName: "trigger",
         code: compiledCode["logic/logic.ts"].code,
         // TODO DCS - how to find the code to run?
         argumentNames: ["data", "request", "state"],
         arguments: [data, request, state, currentTime, utcOffset]
       });
-      return evalResponse.result;
+      if (evalResponse.result) {
+        return evalResponse.result;
+      } else {
+        throw new Error("Trigger failed with message: " + evalResponse.message);
+      }
+    } else {
+      throw new Error("Only TypeScript is supported at this time");
+    }
+  }
+  /**
+   * Init the logic of a template
+   * @param {[string]} currentTime - the current time, defaults to now
+   * @param {[number]} utcOffset - the UTC offer, defaults to zero
+   * @returns {Promise} the response and any events
+   */
+  async init(data, currentTime, utcOffset) {
+    const logicManager = this.template.getLogicManager();
+    if (logicManager.getLanguage() === "typescript") {
+      const compiledCode = {};
+      const tsFiles = logicManager.getScriptManager().getScriptsForTarget("typescript");
+      for (let n = 0; n < tsFiles.length; n++) {
+        const tsFile = tsFiles[n];
+        const compiler = new TypeScriptToJavaScriptCompiler(
+          this.template.getModelManager(),
+          this.template.getTemplateModel().getFullyQualifiedName()
+        );
+        await compiler.initialize();
+        const code = `${Buffer.from(SMART_LEGAL_CONTRACT_BASE64, "base64").toString()}
+                ${tsFile.getContents()}`;
+        const result = compiler.compile(code);
+        compiledCode[tsFile.getIdentifier()] = result;
+      }
+      const evaluator = new JavaScriptEvaluator();
+      const evalResponse = await evaluator.evalDangerously({
+        templateLogic: true,
+        verbose: false,
+        functionName: "init",
+        code: compiledCode["logic/logic.ts"].code,
+        // TODO DCS - how to find the code to run?
+        argumentNames: ["data"],
+        arguments: [data, currentTime, utcOffset]
+      });
+      if (evalResponse.result) {
+        return evalResponse.result;
+      } else {
+        throw new Error("Init failed with message: " + evalResponse.message);
+      }
     } else {
-      return -1;
+      throw new Error("Only TypeScript is supported at this time");
     }
   }
 }