vintasend-managed-templates 1.0.0-alpha2

package/dist/managed-template-service.d.ts

@@ -0,0 +1,415 @@
+/**
+ * Backend-agnostic service for managing template versions and their statuses.
+ *
+ * `ManagedTemplateService` sits between a host application and the two seams this package
+ * defines: a `BaseTemplateManagerBackend` (where templates live) and a `ManagedTemplateRenderer`
+ * (how a template turns into something an adapter can send). Every storage call goes through the
+ * backend, so the service works unchanged against any implementation of that interface.
+ *
+ * What the service adds on top of the raw backend:
+ *
+ * * **Version resolution.** An absent `version` consistently means "the latest version of this
+ *   key" across reads, status changes, and rendering, so callers never juggle version numbers
+ *   unless they want a specific one.
+ * * **Status transitions.** Status changes are validated against `allowedStatusTransitions` and
+ *   then written through the backend's audit trail, with named helpers (`activate` /
+ *   `deactivate` / `archive`) for the common moves.
+ * * **Filter validation.** Filters are checked for shape and field names before they reach the
+ *   backend, so a typo throws `ManagedTemplateInvalidFilterError` here instead of silently
+ *   matching nothing (or blowing up) deep inside a backend's query translation.
+ * * **Tag hygiene.** Tag text is normalized and slugified here before it reaches the backend, so
+ *   every implementation of the storage seam is handed the same slug for the same text, and text
+ *   with nothing sluggable in it is rejected with `ManagedTemplateInvalidTagError` instead of
+ *   becoming a tag no filter can ever name.
+ * * **Version-pinned rendering.** Rendering honours a notification's own
+ *   `requestedTemplateVersion`, so a notification recorded against v3 renders v3 however many
+ *   versions follow. The service adds an explicit `version` argument on top, overriding even
+ *   that — which is what makes previewing an unpublished draft possible — and reports which
+ *   version actually rendered, for the caller to record.
+ * * **Composition.** Templates are flattened before they render: a template that extends a base
+ *   or includes a fragment reaches the engine as one string with no `managed_*` tag left in it
+ *   (see `composition`). Reads are unaffected — `getTemplate` still hands back exactly what is
+ *   stored, and `getComposedTemplate` is the explicit way to ask for the assembled form.
+ *
+ * Two deliberate non-policies, both chosen so the service stays a thin orchestration layer:
+ *
+ * * A key may have **any number of active versions at once**. Activating a version does not touch
+ *   the ones already active; deciding which active version wins at render time is the host's call.
+ * * `changedBy` is **passed through untouched**, `null` included. The service never requires
+ *   attribution on a status change.
+ */
+import type { AnyNotification, BaseNotificationTypeConfig, JsonObject } from 'vintasend';
+import type { BaseTemplateManagerBackend } from './base-template-manager-backend.js';
+import { TemplateComposer, type TemplateReference } from './composition.js';
+import type { ManagedTemplateStatus, ManagedTemplateTagStatus } from './constants.js';
+import { type ManagedTemplateFilter, type ManagedTemplateFilterCapabilities, type ManagedTemplateOrderBy, type ManagedTemplateOrderByField } from './filters.js';
+import type { ManagedTemplateRenderer, ManagedTemplateRenderResult } from './managed-template-renderer.js';
+import type { ManagedTemplate, ManagedTemplateCreateInput, ManagedTemplateStatusHistory, ManagedTemplateTag, ManagedTemplateUpdateInput } from './types.js';
+/**
+ * Which status a version may move to, keyed by the status it is in now.
+ *
+ * `archived` is terminal: an archived version is a historical record, and bringing one back would
+ * make its audit trail read as though it had never been retired. Publish a new version instead.
+ */
+export declare const DEFAULT_STATUS_TRANSITIONS: Readonly<Record<ManagedTemplateStatus, readonly ManagedTemplateStatus[]>>;
+export type ManagedTemplateServiceOptions = {
+    /**
+     * When true (the default), a status change must appear in `allowedStatusTransitions` for the
+     * version's current status. Set false to let any status move to any other and leave the
+     * ordering entirely to the host.
+     */
+    validateStatusTransitions?: boolean;
+    /**
+     * When true (the default), a template is flattened before it is rendered —
+     * `{% managed_extends %}` / `{% managed_include %}` and the rest are resolved against this
+     * service's backend. Set false to hand the engine what is stored, verbatim.
+     */
+    composeTemplates?: boolean;
+    /**
+     * The composer that does it. Defaults to one reading through the template manager backend, so
+     * composition resolves against the same store the service reads from rather than through
+     * whatever backend the renderer happens to hold.
+     */
+    composer?: TemplateComposer;
+    /** A lifecycle other than the default one. */
+    allowedStatusTransitions?: Readonly<Record<ManagedTemplateStatus, readonly ManagedTemplateStatus[]>>;
+};
+export declare class ManagedTemplateService<Config extends BaseNotificationTypeConfig, RenderedType = unknown, ContentType = unknown> {
+    readonly templateManagerBackend: BaseTemplateManagerBackend;
+    readonly templateRenderer: ManagedTemplateRenderer<Config, RenderedType, ContentType>;
+    readonly validateStatusTransitions: boolean;
+    readonly composeTemplates: boolean;
+    readonly composer: TemplateComposer;
+    readonly allowedStatusTransitions: Readonly<Record<ManagedTemplateStatus, readonly ManagedTemplateStatus[]>>;
+    private capabilitiesCache;
+    /**
+     * @param templateManagerBackend where templates are stored and versioned.
+     * @param templateRenderer turns a `ManagedTemplate` into something an adapter can send. The
+     *   service drives its `createTemplateContent` / `renderFromTemplateContent` pair rather than
+     *   its own backend read, so the renderer only needs to agree with this service on the shape of
+     *   a template, not on where templates live.
+     */
+    constructor(templateManagerBackend: BaseTemplateManagerBackend, templateRenderer: ManagedTemplateRenderer<Config, RenderedType, ContentType>, options?: ManagedTemplateServiceOptions);
+    /**
+     * The backend's capability report, merged over the library default.
+     *
+     * Cached for the life of the service: a backend's capabilities are a static property of its
+     * implementation, so re-asking on every request would buy nothing.
+     */
+    getBackendSupportedFilterCapabilities(): ManagedTemplateFilterCapabilities;
+    /**
+     * Create the first version of a new template.
+     *
+     * Any tag text on the input that has no tag behind it yet becomes one, so a caller never has to
+     * create tags before using them.
+     *
+     * @throws ManagedTemplateInvalidTagError if a tag text has nothing that can be slugified.
+     */
+    createTemplate(input: ManagedTemplateCreateInput): Promise<ManagedTemplate>;
+    /**
+     * One version of a template. An absent `version` returns the latest version.
+     *
+     * @throws ManagedTemplateNotFoundError if the key (or that version of it) does not exist.
+     */
+    getTemplate(templateKey: string, version?: number | null): Promise<ManagedTemplate>;
+    /**
+     * Create a new version of an existing template from the latest one.
+     *
+     * Templates are versioned rather than edited in place, so this never mutates a version that has
+     * already been published — the backend copies the latest version forward, applies the set
+     * fields of `input`, and returns the new version.
+     *
+     * Tags follow the same rule as every other field on the input: absent carries the previous
+     * version's tags forward, and an empty array means a version with none.
+     */
+    updateTemplate(templateKey: string, input: ManagedTemplateUpdateInput): Promise<ManagedTemplate>;
+    /**
+     * Delete one version of a template, or its latest version when `version` is absent.
+     */
+    deleteTemplate(templateKey: string, version?: number | null): Promise<void>;
+    /** Every version of a template, newest version first. */
+    getTemplateVersions(templateKey: string): Promise<ManagedTemplate[]>;
+    private withCleanTags;
+    /**
+     * Move one version of a template to `status` and record it in the audit trail.
+     *
+     * Setting a version to the status it already holds is a no-op: the template is returned
+     * unchanged and no history entry is written, so repeating a call does not fill the audit trail
+     * with entries that record nothing.
+     *
+     * @throws ManagedTemplateNotFoundError if the key (or that version of it) does not exist.
+     * @throws ManagedTemplateStatusTransitionError if the move is not allowed from the version's
+     *   current status and `validateStatusTransitions` is on.
+     */
+    setStatus(templateKey: string, status: ManagedTemplateStatus, version?: number | null, changedBy?: string | null): Promise<ManagedTemplate>;
+    /**
+     * Publish one version of a template.
+     *
+     * Other versions of the same key that are already active are left alone — a key may hold
+     * several active versions at once, and choosing between them is the host's call.
+     */
+    activate(templateKey: string, version?: number | null, changedBy?: string | null): Promise<ManagedTemplate>;
+    /** Retire one version without archiving it, so it can be activated again. */
+    deactivate(templateKey: string, version?: number | null, changedBy?: string | null): Promise<ManagedTemplate>;
+    /** Archive one version. Terminal under the default transition table. */
+    archive(templateKey: string, version?: number | null, changedBy?: string | null): Promise<ManagedTemplate>;
+    /**
+     * The status audit trail for a template, most recent change first.
+     *
+     * @param version every version's history when absent, if the backend supports it.
+     */
+    getStatusHistory(templateKey: string, version?: number | null): Promise<ManagedTemplateStatusHistory[]>;
+    /** Every template version in any of the given statuses. */
+    getTemplatesByStatus(status: ManagedTemplateStatus[]): Promise<ManagedTemplate[]>;
+    /**
+     * Whether `template` may move to `status`, without attempting the move.
+     *
+     * Lets a caller (a UI deciding which buttons to enable, say) ask the same question `setStatus`
+     * asks, instead of catching the exception to find out.
+     */
+    canTransitionTo(template: ManagedTemplate, status: ManagedTemplateStatus): boolean;
+    /**
+     * Which statuses `template` may move to right now, in a stable order.
+     *
+     * The version's current status is excluded even though `canTransitionTo` returns true for it:
+     * setting a version to the status it already holds is a documented no-op, not a transition, and
+     * offering it as an action would be offering to do nothing.
+     */
+    allowedTransitionsFor(template: ManagedTemplate): ManagedTemplateStatus[];
+    private checkStatusTransition;
+    /**
+     * Create a tag, failing if its text already slugs onto an existing one.
+     *
+     * Tagging a template creates missing tags on its own, so this is for the case where a tag is
+     * being defined ahead of any template using it — and where a collision with an existing tag is
+     * worth hearing about rather than silently resolving.
+     */
+    createTag(text: string, tenant?: string | null): Promise<ManagedTemplateTag>;
+    /** One tag by slug, or by the text it was created from. */
+    getTag(slug: string): Promise<ManagedTemplateTag>;
+    /** Tags, optionally narrowed by status, by a text search, or by tenant. */
+    getTags(status?: ManagedTemplateTagStatus[] | null, search?: string | null, tenant?: string | null): Promise<ManagedTemplateTag[]>;
+    /** The tags still on offer — what a tag picker should show. */
+    getActiveTags(tenant?: string | null): Promise<ManagedTemplateTag[]>;
+    /**
+     * Rename a tag, regenerating its slug from the new text.
+     *
+     * The templates carrying the tag keep it. The slug changes, though, so a saved filter naming
+     * the old slug stops matching — a rename is a change of identity, not a display change.
+     */
+    updateTag(slug: string, text: string): Promise<ManagedTemplateTag>;
+    /** Retire a tag from the pickers without touching the templates carrying it. */
+    archiveTag(slug: string): Promise<ManagedTemplateTag>;
+    /**
+     * Put an archived tag back on offer.
+     *
+     * Unlike an archived template version — terminal, because reviving one would rewrite what its
+     * audit trail says happened — a tag carries no history to contradict, so archiving one is
+     * reversible.
+     */
+    restoreTag(slug: string): Promise<ManagedTemplateTag>;
+    setTagStatus(slug: string, status: ManagedTemplateTagStatus): Promise<ManagedTemplateTag>;
+    /** Delete a tag, removing it from every template carrying it. */
+    deleteTag(slug: string): Promise<void>;
+    /** Resolve tag texts to tags, creating the ones that do not exist yet. */
+    getOrCreateTags(texts: string[], tenant?: string | null): Promise<ManagedTemplateTag[]>;
+    /** The tags on one version of a template, or on its latest version. */
+    getTemplateTags(templateKey: string, version?: number | null): Promise<ManagedTemplateTag[]>;
+    /**
+     * Replace the tags on one version of a template, creating any that do not exist.
+     *
+     * Retagging edits the version in place instead of creating a new one: tags are how a template
+     * is found, not part of what it renders, so relabelling should not spawn a version and drop it
+     * back to `draft`.
+     */
+    setTemplateTags(templateKey: string, tags: string[], version?: number | null): Promise<ManagedTemplate>;
+    /** Add tags to a version, leaving the ones already on it in place. */
+    addTemplateTags(templateKey: string, tags: string[], version?: number | null): Promise<ManagedTemplate>;
+    /**
+     * Remove tags from a version. Tags it does not carry are ignored.
+     *
+     * The tags themselves survive — this unlinks them from one version, it does not delete them.
+     */
+    removeTemplateTags(templateKey: string, tags: string[], version?: number | null): Promise<ManagedTemplate>;
+    /**
+     * The templates carrying these tags — all of them, or any of them.
+     *
+     * A shorthand for the `includesAllTags` / `includesAnyOfTags` filters, which is what it builds.
+     * Follows the same empty-collection rule they do: matching *all* of no tags returns everything,
+     * matching *any* of no tags returns nothing.
+     */
+    getTemplatesByTags(tags: string[], matchAll?: boolean): Promise<ManagedTemplate[]>;
+    /**
+     * Trim a tag's text, rejecting it when nothing sluggable is left.
+     *
+     * Checked here rather than left to the backend so every backend is handed text it can slugify,
+     * and so a caller hears about `'  '` or `'!!!'` at the call site instead of ending up with a
+     * tag whose slug is empty and which no filter can name.
+     */
+    private cleanTagText;
+    /** Clean each text, dropping repeats that slug onto a tag already in the list. */
+    private cleanTagTexts;
+    /**
+     * Slugify a caller's tag texts, dropping the ones with nothing sluggable.
+     *
+     * Unlike `cleanTagTexts` this never throws: these slugs are used to *match*, and a tag no store
+     * could hold simply matches nothing — which is a correct answer, not an error worth
+     * interrupting a search for.
+     */
+    private static slugsFor;
+    /**
+     * The current version of every template — one row per key.
+     *
+     * "Current" is the `mostRecentActiveVersion` filter: the highest-numbered active or draft
+     * version of each key. It is the default because a listing is nearly always a list of
+     * *templates*, and the store holds a row per *version*, so the unfiltered read shows the same
+     * template once per version it has ever had and hides the current one among its own history.
+     *
+     * Pass `includeAllVersions: true` for the raw read.
+     */
+    getAllTemplates(includeAllVersions?: boolean): Promise<ManagedTemplate[]>;
+    /**
+     * The templates matching `filters`.
+     *
+     * @throws ManagedTemplateInvalidFilterError if the filter is malformed or names an unknown
+     *   field.
+     */
+    getFilteredTemplates(filters: ManagedTemplateFilter): Promise<ManagedTemplate[]>;
+    /**
+     * The filter with everything the backend cannot answer removed.
+     *
+     * A capability report nothing acts on is decoration, and every caller left to walk the map
+     * itself would reach a slightly different conclusion. Dropping only ever widens the result, so
+     * the failure mode is extra rows a caller can see — `getAllTemplates()` against a backend that
+     * cannot answer `mostRecentActiveVersion` returns every version rather than throwing.
+     *
+     * Ordering is *not* negotiated here. It is refused instead, because dropping it leaves no
+     * trace in the rows for a caller to notice.
+     */
+    private negotiate;
+    /**
+     * One page of templates, one row per key by default.
+     *
+     * @param page 1-indexed.
+     */
+    getPaginatedTemplates(page: number, pageSize: number, includeAllVersions?: boolean, orderBy?: ManagedTemplateOrderBy): Promise<ManagedTemplate[]>;
+    /**
+     * One page of the templates matching `filters`.
+     *
+     * @param page 1-indexed.
+     */
+    getPaginatedFilteredTemplates(filters: ManagedTemplateFilter, page: number, pageSize: number, orderBy?: ManagedTemplateOrderBy): Promise<ManagedTemplate[]>;
+    /**
+     * Refuse an order the backend cannot apply, rather than passing it on to be ignored.
+     *
+     * Unlike an unsupported filter — which a caller drops, getting more rows than it asked for and
+     * being able to tell — an ignored order returns exactly the rows requested in an arbitrary
+     * sequence. Nothing downstream can detect that, so the only honest options are to apply it or
+     * to refuse, and the backend has already said which one this is.
+     */
+    validateOrderBy(orderBy: ManagedTemplateOrderBy | undefined): void;
+    /** Every field this backend can order a listing by, in vocabulary order. */
+    getSupportedOrderByFields(): ManagedTemplateOrderByField[];
+    /**
+     * Check a filter's shape and field names, throwing rather than passing a broken filter on.
+     *
+     * A backend translating an unknown field usually either matches nothing or throws something
+     * backend-specific, both of which are hard to debug from the call site. This catches the common
+     * mistakes — a typo'd field name, an `and`/`or` that is not an array, a logical group carrying
+     * sibling keys — while the caller's own frame is still on the stack. It does not validate
+     * lookup values; the backend remains the authority there.
+     *
+     * @throws ManagedTemplateInvalidFilterError if the filter is malformed or names an unknown
+     *   field.
+     */
+    validateFilter(filters: ManagedTemplateFilter, path?: string): void;
+    /**
+     * Reject a tag filter that is not an array of strings.
+     *
+     * One of the two value checks `validateFilter` does make, because the failure it prevents is
+     * silent rather than loud: a bare `'welcome'` would have a backend ask for the tags `w`, `e`,
+     * `l`, `c` and return nothing, with no error anywhere.
+     */
+    private validateTagFields;
+    /**
+     * Reject a flag filter whose value is not a boolean.
+     *
+     * Checked for the same reason the tag fields are: the failure is silent otherwise. A backend
+     * reads a flag for its truthiness, so the string `'false'` — what a query parameter that
+     * skipped parsing arrives as — would ask for exactly what the caller meant to switch off.
+     */
+    private validateFlagFields;
+    private static validatePagination;
+    /**
+     * Flatten a template's inheritance and inclusion into a single self-contained one.
+     *
+     * Composition is what a store-backed template has instead of an engine loader: the engine is
+     * handed source rather than a name, so a `{% managed_extends %}` here is resolved against the
+     * backend before the engine ever sees the template. The result has no `managed_*` tag left in
+     * it, and the engine's own syntax is untouched.
+     *
+     * A no-op — returning the very template it was given — when the template composes to itself,
+     * and when the service was built with `composeTemplates: false`.
+     */
+    composeTemplate(template: ManagedTemplate): Promise<ManagedTemplate>;
+    /**
+     * One version of a template, assembled as the engine will receive it.
+     *
+     * The counterpart to `getTemplate`, which is deliberately literal about what is stored.
+     */
+    getComposedTemplate(templateKey: string, version?: number | null): Promise<ManagedTemplate>;
+    /**
+     * Assemble a template and throw the result away, to surface any problem now.
+     *
+     * What a form or a deploy check calls: it throws exactly what rendering would have thrown — a
+     * malformed tag, a base that does not exist, a loop — at a point where someone can still fix it
+     * rather than at send time.
+     */
+    validateComposition(template: ManagedTemplate): Promise<void>;
+    /**
+     * The templates one template directly extends or includes.
+     *
+     * Direct references only, and nothing is resolved, so this answers "what does this template
+     * name" without needing any of them to exist.
+     */
+    getTemplateReferences(template: ManagedTemplate): TemplateReference[];
+    /**
+     * Whether a template is a base to build on rather than one to send.
+     *
+     * Read off the source every time it is asked, which makes it the authority:
+     * `template.isAbstract` is a backend's stored copy of this answer, kept for the `isAbstract`
+     * filter to query, and this is what that copy is supposed to say.
+     *
+     * To *find* the bases rather than test one, filter on the stored flag — it is indexed and this
+     * is not:
+     *
+     * ```ts
+     * await service.getFilteredTemplates({ isAbstract: false }); // everything sendable
+     * ```
+     *
+     * Neither one refuses anything: the service renders an abstract template quite happily, and
+     * gives you the layout with an empty hole. Keeping bases out of a picker is the host's call.
+     */
+    isAbstract(template: ManagedTemplate): boolean;
+    /**
+     * Render a notification against a specific version of its template.
+     *
+     * The notification's `bodyTemplate` is the template key. Which version renders is decided in
+     * this order: the `version` argument, then the notification's own `requestedTemplateVersion`,
+     * then whatever the backend considers current.
+     *
+     * The argument is there to render a version the notification is *not* pinned to — previewing an
+     * unpublished draft, or reproducing what an old notification looked like. Leave it off and this
+     * renders what a real send would.
+     */
+    render(notification: AnyNotification<Config>, context: JsonObject, version?: number | null): Promise<ManagedTemplateRenderResult<RenderedType>>;
+    /**
+     * Render a notification against a template already in hand, with no backend read.
+     *
+     * The template is composed by this service — through *its* composer and *its*
+     * `composeTemplates` setting, not the renderer's — so one already fetched and edited in memory
+     * renders the same way a stored one does.
+     */
+    renderTemplate(notification: AnyNotification<Config>, template: ManagedTemplate, context: JsonObject): Promise<ManagedTemplateRenderResult<RenderedType>>;
+}
+//# sourceMappingURL=managed-template-service.d.ts.map

package/dist/managed-template-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-template-service.d.ts","sourceRoot":"","sources":["../src/managed-template-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,0BAA0B,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEzF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAOtF,OAAO,EAOL,KAAK,qBAAqB,EAC1B,KAAK,iCAAiC,EAEtC,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAIjC,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACV,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAC1B,4BAA4B,EAC5B,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAC/C,MAAM,CAAC,qBAAqB,EAAE,SAAS,qBAAqB,EAAE,CAAC,CAMhE,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,8CAA8C;IAC9C,wBAAwB,CAAC,EAAE,QAAQ,CACjC,MAAM,CAAC,qBAAqB,EAAE,SAAS,qBAAqB,EAAE,CAAC,CAChE,CAAC;CACH,CAAC;AA0BF,qBAAa,sBAAsB,CACjC,MAAM,SAAS,0BAA0B,EACzC,YAAY,GAAG,OAAO,EACtB,WAAW,GAAG,OAAO;IAsBnB,QAAQ,CAAC,sBAAsB,EAAE,0BAA0B;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,uBAAuB,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,CAAC;IArBvF,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;IAE5C,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IAEnC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IAEpC,QAAQ,CAAC,wBAAwB,EAAE,QAAQ,CACzC,MAAM,CAAC,qBAAqB,EAAE,SAAS,qBAAqB,EAAE,CAAC,CAChE,CAAC;IAEF,OAAO,CAAC,iBAAiB,CAAkD;IAE3E;;;;;;OAMG;gBAEQ,sBAAsB,EAAE,0BAA0B,EAClD,gBAAgB,EAAE,uBAAuB,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,CAAC,EACrF,OAAO,GAAE,6BAAkC;IAY7C;;;;;OAKG;IACH,qCAAqC,IAAI,iCAAiC;IAiB1E;;;;;;;OAOG;IACG,cAAc,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,eAAe,CAAC;IAIjF;;;;OAIG;IACG,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAAC,eAAe,CAAC;IAI/F;;;;;;;;;OASG;IACG,cAAc,CAClB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,eAAe,CAAC;IAI3B;;OAEG;IACG,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvF,yDAAyD;IACnD,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAK1E,OAAO,CAAC,aAAa;IAWrB;;;;;;;;;;OAUG;IACG,SAAS,CACb,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,qBAAqB,EAC7B,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,SAAS,GAAE,MAAM,GAAG,IAAW,GAC9B,OAAO,CAAC,eAAe,CAAC;IAqB3B;;;;;OAKG;IACG,QAAQ,CACZ,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,SAAS,GAAE,MAAM,GAAG,IAAW,GAC9B,OAAO,CAAC,eAAe,CAAC;IAI3B,6EAA6E;IACvE,UAAU,CACd,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,SAAS,GAAE,MAAM,GAAG,IAAW,GAC9B,OAAO,CAAC,eAAe,CAAC;IAI3B,wEAAwE;IAClE,OAAO,CACX,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,SAAS,GAAE,MAAM,GAAG,IAAW,GAC9B,OAAO,CAAC,eAAe,CAAC;IAI3B;;;;OAIG;IACG,gBAAgB,CACpB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,4BAA4B,EAAE,CAAC;IAoB1C,2DAA2D;IACrD,oBAAoB,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAIvF;;;;;OAKG;IACH,eAAe,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,qBAAqB,GAAG,OAAO;IAOlF;;;;;;OAMG;IACH,qBAAqB,CAAC,QAAQ,EAAE,eAAe,GAAG,qBAAqB,EAAE;IAMzE,OAAO,CAAC,qBAAqB;IAgB7B;;;;;;OAMG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIxF,2DAA2D;IACrD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIvD,2EAA2E;IACrE,OAAO,CACX,MAAM,GAAE,wBAAwB,EAAE,GAAG,IAAW,EAChD,MAAM,GAAE,MAAM,GAAG,IAAW,EAC5B,MAAM,GAAE,MAAM,GAAG,IAAW,GAC3B,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAIhC,+DAA+D;IACzD,aAAa,CAAC,MAAM,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAIhF;;;;;OAKG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIxE,gFAAgF;IAC1E,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAI3D;;;;;;OAMG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIrD,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAI/F,iEAAiE;IAC3D,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,0EAA0E;IACpE,eAAe,CACnB,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,GAAE,MAAM,GAAG,IAAW,GAC3B,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAIhC,uEAAuE;IACjE,eAAe,CACnB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAIhC;;;;;;OAMG;IACG,eAAe,CACnB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,eAAe,CAAC;IAQ3B,sEAAsE;IAChE,eAAe,CACnB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,eAAe,CAAC;IAU3B;;;;OAIG;IACG,kBAAkB,CACtB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,eAAe,CAAC;IAU3B;;;;;;OAMG;IACG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,UAAO,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAOrF;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAUpB,kFAAkF;IAClF,OAAO,CAAC,aAAa;IAerB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ;IAevB;;;;;;;;;OASG;IACG,eAAe,CAAC,kBAAkB,UAAQ,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAO7E;;;;;OAKG;IACG,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAKtF;;;;;;;;;;OAUG;IACH,OAAO,CAAC,SAAS;IAIjB;;;;OAIG;IACG,qBAAqB,CACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,kBAAkB,UAAQ,EAC1B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,eAAe,EAAE,CAAC;IAS7B;;;;OAIG;IACG,6BAA6B,CACjC,OAAO,EAAE,qBAAqB,EAC9B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,eAAe,EAAE,CAAC;IAY7B;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,SAAS,GAAG,IAAI;IA0BlE,4EAA4E;IAC5E,yBAAyB,IAAI,2BAA2B,EAAE;IAO1D;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,OAAO,EAAE,qBAAqB,EAAE,IAAI,SAAY,GAAG,IAAI;IAsDtE;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAezB;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAajC;;;;;;;;;;OAUG;IACG,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAO1E;;;;OAIG;IACG,mBAAmB,CACvB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,eAAe,CAAC;IAI3B;;;;;;OAMG;IACG,mBAAmB,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAInE;;;;;OAKG;IACH,qBAAqB,CAAC,QAAQ,EAAE,eAAe,GAAG,iBAAiB,EAAE;IAIrE;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO;IAQ9C;;;;;;;;;;OAUG;IACG,MAAM,CACV,YAAY,EAAE,eAAe,CAAC,MAAM,CAAC,EACrC,OAAO,EAAE,UAAU,EACnB,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,OAAO,CAAC,2BAA2B,CAAC,YAAY,CAAC,CAAC;IAIrD;;;;;;OAMG;IACG,cAAc,CAClB,YAAY,EAAE,eAAe,CAAC,MAAM,CAAC,EACrC,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,2BAA2B,CAAC,YAAY,CAAC,CAAC;CAUtD"}