mlform 0.1.0

package/dist/regressor-prediction-C18dHlfK.js

@@ -0,0 +1,236 @@
+import { i as m, x as l, a as v, n as c } from "./property-jKFNMQpR.js";
+import { t as h } from "./custom-element-ttkHUa8w.js";
+var p = Object.defineProperty, u = Object.getOwnPropertyDescriptor, x = (t, i, e) => i in t ? p(t, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[i] = e, o = (t, i, e, r) => {
+  for (var a = r > 1 ? void 0 : r ? u(i, e) : i, n = t.length - 1, d; n >= 0; n--)
+    (d = t[n]) && (a = (r ? d(i, e, a) : d(a)) || a);
+  return r && a && p(i, e, a), a;
+}, b = (t, i, e) => x(t, i + "", e);
+let s = class extends m {
+  title = "";
+  values = [];
+  unit = "";
+  firstUpdated() {
+    if (this.interval !== void 0)
+      this.min = this.interval[0], this.max = this.interval[1];
+    else {
+      this.values = this.values.map((e) => Number(e));
+      const t = this.values.reduce((e, r) => e + r, 0) / this.values.length, i = this.values.reduce((e, r) => e + r, 0);
+      this.min = t - i, this.max = t + i;
+    }
+    this.requestUpdate();
+  }
+  /* —— Utilidades —— */
+  _barExtents() {
+    const t = this.max - this.min;
+    return [this.min - t, this.max + t];
+  }
+  /* —— Utilidades —— */
+  _hasInterval() {
+    return this.interval !== void 0 && this.min !== void 0 && this.max !== void 0;
+  }
+  _calcPercent(t) {
+    const [i, e] = this._barExtents();
+    return (t - i) / (e - i) * 100;
+  }
+  /** Gradiente lineal continuo: rojo → naranja → amarillo → verde → amarillo → naranja → rojo */
+  _buildGradient() {
+    const t = this._calcPercent(this.min), i = this._calcPercent(this.max), e = this._calcPercent((this.min + this.max) / 2), r = 10, a = Math.max(t - r, 0), n = Math.min(i + r, 100);
+    return `linear-gradient(to right,
+      #c62828 0%,
+      #ff6d00 ${a}%,
+      #ffea00 ${t}%,
+      #00c853 ${e}%,
+      #ffea00 ${i}%,
+      #ff6d00 ${n}%,
+      #c62828 100%)`;
+  }
+  /* —— Render —— */
+  render() {
+    return this._hasInterval() ? l`
+      <div class="prediction-card">
+        ${this.title ? l`<div class="title">${this.title}</div>` : null}
+        ${this.values.map(
+      (t) => l`
+            <div class="item">
+              <div class="value">${t} ${this.unit}</div>
+
+              <div
+                class="bar-wrapper"
+                style="background: ${this._buildGradient()};"
+              >
+                <!-- Límite inferior -->
+                <div
+                  class="limit-wrapper"
+                  style="left: ${this._calcPercent(this.min)}%; top: -12px;"
+                >
+                  <div class="limit-line"></div>
+                  <div class="limit-label">${this.min} ${this.unit}</div>
+                </div>
+
+                <!-- Límite superior -->
+                <div
+                  class="limit-wrapper"
+                  style="left: ${this._calcPercent(this.max)}%; top: -12px;"
+                >
+                  <div class="limit-line"></div>
+                  <div class="limit-label">${this.max} ${this.unit}</div>
+                </div>
+
+                <!-- Valor actual -->
+                <span
+                  class="value-marker"
+                  style="left: ${Math.min(
+        Math.max(this._calcPercent(t), 0),
+        98.45
+      )}%;
+                  top: 10%;"
+                ></span>
+              </div>
+            </div>
+          `
+    )}
+      </div>
+    ` : l`<div class="prediction-card">
+        ${this.title ? l`<div class="title">${this.title}</div>` : null}
+        ${this.values.map(
+      (t) => l`
+            <div class="item">
+              <div class="value">${t} ${this.unit}</div>
+            </div>
+            </div>
+          `
+    )}
+      </div>`;
+  }
+};
+b(s, "styles", v`
+    :host {
+      --marker-width: 4px; /* valor actual */
+      --limit-line-width: 3px; /* nuevo: marcador de límite */
+      --limit-line-height: 28px; /* sobresale 6px por arriba y por abajo (barra = 16px) */
+      
+      display: block;
+      margin: 10px;
+    }
+
+    .prediction-card {
+      padding: 25px;
+      border: 1px solid var(--ml-color-border);
+      border-radius: var(--radius);
+      box-shadow: 0 4px 12px var(--ml-color-shadow);
+      background: var(--ml-color-surface);
+    }
+
+    .title {
+      font-size: 1rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      color: var(--ml-color-secondary);
+    }
+
+    .value {
+      display: flex;
+      justify-content: flex-end;
+      font-size: 1rem;
+      font-weight: 700;
+      color: var(--ml-color-primary);
+      margin-bottom: 5px;
+    }
+
+    .item {
+      margin-top: 15px;
+    }
+
+    .bar-wrapper {
+      position: relative;
+      height: 16px;
+      border-radius: 5px;
+    }
+
+    /* —— Marcador de la medida —— */
+    .value-marker {
+      position: absolute;
+      height: 14px;
+      width: 14px;
+      border-radius: 50%;
+      background: radial-gradient(circle, var(--ml-color-accent), var(--ml-color-accent-h));
+    }
+
+    /* —— Wrapper del límite: línea + etiqueta —— */
+    .limit-wrapper {
+      position: absolute;
+      top: calc(
+        -1 * (var(--limit-line-height) - 16px) / 2
+      ); /* centra la línea respecto a la barra y hace que sobresalga */
+      transform: translateX(-50%);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      pointer-events: none;
+      z-index: 2;
+    }
+
+    .limit-line {
+      width: var(--limit-line-width);
+      height: var(--limit-line-height);
+      background: var(--ml-color-primary);
+      opacity: 0.6;
+    }
+
+    .limit-label {
+      font-size: 0.75rem;
+      color: var(--ml-color-secondary);
+      margin-top: 4px;
+      white-space: nowrap;
+    }
+  `);
+o([
+  c({ type: String })
+], s.prototype, "title", 2);
+o([
+  c({
+    type: Array,
+    attribute: "values",
+    converter: {
+      fromAttribute: (t) => {
+        if (!t) return [];
+        try {
+          const i = JSON.parse(t);
+          return Array.isArray(i) ? i.map(Number) : [i];
+        } catch {
+          return t.split(/[,;]/).map((i) => Number(i.trim()));
+        }
+      }
+    }
+  })
+], s.prototype, "values", 2);
+o([
+  c({ type: String })
+], s.prototype, "unit", 2);
+o([
+  c({
+    type: Object,
+    attribute: "interval",
+    converter: {
+      fromAttribute: (t) => {
+        if (t) {
+          try {
+            const e = JSON.parse(t);
+            if (Array.isArray(e) && e.length === 2 && e.every((r) => typeof r == "number"))
+              return e;
+          } catch {
+          }
+          const i = t.split(/[,;]/).map((e) => Number(e.trim()));
+          return [i[0], i[1]];
+        } else
+          return;
+      }
+    }
+  })
+], s.prototype, "interval", 2);
+s = o([
+  h("regressor-prediction")
+], s);
+export {
+  s as RegressorPrediction
+};

package/dist/src/core/app/DescriptorItem.d.ts

@@ -0,0 +1,6 @@
+export interface DescriptorItem {
+    tag: string;
+    props: Record<string, unknown>;
+    child?: DescriptorItem;
+    slot: "inputs" | "report" | "layout";
+}

package/dist/src/core/app/DescriptorRegistry.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from '../domain';
+import { DescriptorStrategy } from './DescriptorStrategy';
+export declare class DescriptorRegistry {
+    private readonly catalog;
+    private combinedSchema;
+    get schema(): Schema;
+    get(type: string): DescriptorStrategy | undefined;
+    values(): IterableIterator<DescriptorStrategy>;
+    register(item: DescriptorStrategy): void;
+    unregister(type: string): void;
+    update(item: DescriptorStrategy): void;
+    private rebuildSchema;
+}

package/dist/src/core/app/DescriptorService.d.ts

@@ -0,0 +1,22 @@
+import { Base, Output } from '../domain';
+import { DescriptorItem } from './DescriptorItem';
+import { DescriptorRegistry } from './DescriptorRegistry';
+export declare class DescriptorService {
+    protected readonly registry: DescriptorRegistry;
+    protected backendUrl: string;
+    private readonly loadedTypes;
+    protected temporalOutputs: unknown;
+    constructor(backendUrl?: string);
+    get reg(): DescriptorRegistry;
+    set tmpOutputs(value: unknown);
+    mount(data: Base, host: HTMLElement): Promise<void>;
+    protected ensureComponents(data: Base): Promise<void>;
+    protected renderDescriptors(data: Base): DescriptorItem[];
+    protected descriptorsToInnerHtml(list: DescriptorItem[]): string;
+    protected reportDescriptorsToInnerHtml(descriptors: DescriptorItem[]): string;
+    render(data: Output): Promise<void>;
+    submit(data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private renderDescriptor;
+    /** Serializa el objeto `props` a atributos HTML. */
+    private propsToAttrs;
+}

package/dist/src/core/app/DescriptorStrategy.d.ts

@@ -0,0 +1,11 @@
+import { Infer, Schema } from '../domain';
+import { DescriptorItem } from './DescriptorItem';
+export declare abstract class DescriptorStrategy<S extends Schema = Schema> {
+    readonly type: string;
+    readonly schema: S;
+    readonly loader: () => Promise<unknown>;
+    constructor(type: string, schema: S, loader: () => Promise<unknown>);
+    abstract buildDescriptor(payload: Record<string, unknown>): DescriptorItem;
+    validate(data: S): boolean;
+    parse(data: S): Infer<S>;
+}

package/dist/src/core/app/index.d.ts

@@ -0,0 +1,4 @@
+export type { DescriptorItem } from './DescriptorItem';
+export { DescriptorRegistry } from './DescriptorRegistry';
+export { DescriptorService } from './DescriptorService';
+export { DescriptorStrategy } from './DescriptorStrategy';

package/dist/src/core/domain/index.d.ts

@@ -0,0 +1,24 @@
+import { ZodType, array as zArray, infer as zInfer, union as zUnion } from 'zod';
+import { FieldTypes, ModelTypes } from '../../strategies/domain';
+export declare const array: typeof zArray;
+export declare const union: typeof zUnion;
+export type Schema = ZodType;
+export type Infer<T extends ZodType> = zInfer<T>;
+declare const BaseSchema: import('zod').ZodArray<import('zod').ZodObject<{
+    type: import('zod').ZodUnion<import('zod').ZodLiteral<FieldTypes>[]>;
+}, import('zod/v4/core').$loose>>;
+declare const OutputSchema: import('zod').ZodObject<{
+    type: import('zod').ZodUnion<import('zod').ZodLiteral<ModelTypes>[]>;
+}, import('zod/v4/core').$loose>;
+declare const Signature: import('zod').ZodObject<{
+    inputs: import('zod').ZodArray<import('zod').ZodObject<{
+        type: import('zod').ZodUnion<import('zod').ZodLiteral<FieldTypes>[]>;
+    }, import('zod/v4/core').$loose>>;
+    outputs: import('zod').ZodArray<import('zod').ZodObject<{
+        type: import('zod').ZodUnion<import('zod').ZodLiteral<FieldTypes>[]>;
+    }, import('zod/v4/core').$loose>>;
+}, import('zod/v4/core').$strict>;
+export type Base = Infer<typeof BaseSchema>;
+export type Output = Infer<typeof OutputSchema>;
+export type Signature = Infer<typeof Signature>;
+export {};

package/dist/src/core/index.d.ts

@@ -0,0 +1,3 @@
+export { DescriptorService } from './app';
+export type { Infer, Schema, Signature } from './domain';
+export { array, union } from './domain';

package/dist/src/core/ui/error-card.d.ts

@@ -0,0 +1,38 @@
+import { LitElement } from 'lit';
+export declare class ApiError extends Error {
+    statusCode?: number;
+    code?: string;
+    details?: string[];
+    constructor(message: string, options?: {
+        statusCode?: number;
+        code?: string;
+        details?: string[];
+    });
+}
+interface ErrorConfig {
+    icon: string;
+    title: string;
+    description: string;
+    details?: (error: unknown) => string[];
+}
+export declare class ErrorCard extends LitElement {
+    static styles: import('lit').CSSResult;
+    error: Error | null;
+    retry?: () => void;
+    private static _errorMap;
+    /**
+     * Registers custom error configurations.
+     * @param map A record where keys are error identifiers and values are ErrorConfig objects.
+     */
+    static register(map: Record<string, ErrorConfig>): void;
+    private static defaultErrorConfigs;
+    constructor();
+    private _getErrorConfig;
+    render(): import('lit-html').TemplateResult<1> | null;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "error-card": ErrorCard;
+    }
+}
+export {};

package/dist/src/core/ui/field-wrapper.d.ts

@@ -0,0 +1,23 @@
+import { LitElement } from 'lit';
+export declare class FieldWrapper extends LitElement {
+    static styles: import('lit').CSSResult;
+    title: string;
+    description: string;
+    private descriptionVisible;
+    private stateClass;
+    feedback: string;
+    value: unknown;
+    name: string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    private toggleDescription;
+    private onFieldState;
+    private dispatchState;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "field-wrapper": FieldWrapper;
+    }
+}

package/dist/src/core/ui/index.d.ts

@@ -0,0 +1,3 @@
+export { ErrorCard } from './error-card';
+export { FieldWrapper } from './field-wrapper';
+export { MLLayout } from './ml-layout';

package/dist/src/core/ui/ml-layout.d.ts

@@ -0,0 +1,23 @@
+import { LitElement } from 'lit';
+import { DescriptorService } from '../app';
+export declare class MLLayout extends LitElement {
+    static styles: import('lit').CSSResult;
+    private inputs;
+    modelService: DescriptorService;
+    private label;
+    private _mo?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _onWrapperChange;
+    private get _disableButton();
+    private _onSubmit;
+    private _clearSlot;
+    private _showError;
+    private _hideError;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "ml-layout": MLLayout;
+    }
+}

package/dist/src/extensions/app/FieldStrategy.d.ts

@@ -0,0 +1,10 @@
+import { DescriptorItem, DescriptorStrategy } from '../../core/app';
+import { Infer, Schema } from '../../core/domain';
+export declare abstract class FieldStrategy<S extends Schema = Schema> extends DescriptorStrategy<S> {
+    private static readonly FIELD_SLOT;
+    protected abstract buildControl(field: Infer<S>): {
+        tag: string;
+        props: Record<string, unknown>;
+    };
+    buildDescriptor(field: Infer<S>): DescriptorItem;
+}

package/dist/src/extensions/app/ReportStrategy.d.ts

@@ -0,0 +1,9 @@
+import { DescriptorItem, DescriptorStrategy } from '../../core/app';
+import { Infer, Schema } from '../../core/domain';
+export declare abstract class ReportStrategy<S extends Schema = Schema> extends DescriptorStrategy<S> {
+    protected abstract buildControl(field: Infer<S>): {
+        tag: string;
+        props: Record<string, unknown>;
+    };
+    buildDescriptor(field: Infer<S>): DescriptorItem;
+}

package/dist/src/extensions/app/index.d.ts

@@ -0,0 +1,2 @@
+export { FieldStrategy } from './FieldStrategy';
+export { ReportStrategy } from './ReportStrategy';

package/dist/src/extensions/domain/BaseField.d.ts

@@ -0,0 +1,7 @@
+import * as z from "zod";
+export declare const BaseFieldSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type BaseField = z.infer<typeof BaseFieldSchema>;

package/dist/src/extensions/domain/BaseModel.d.ts

@@ -0,0 +1,6 @@
+import * as z from "zod";
+export declare const BaseModelSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    execution_time: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type BaseModel = z.infer<typeof BaseModelSchema>;

package/dist/src/extensions/domain/index.d.ts

@@ -0,0 +1,2 @@
+export { type BaseField, BaseFieldSchema } from './BaseField';
+export { type BaseModel, BaseModelSchema } from './BaseModel';

package/dist/src/extensions/index.d.ts

@@ -0,0 +1,3 @@
+export { FieldStrategy, ReportStrategy } from './app';
+export { type BaseField, BaseFieldSchema, type BaseModel, BaseModelSchema, } from './domain';
+export { FieldElement } from './ui';

package/dist/src/extensions/ui/field-element.d.ts

@@ -0,0 +1,9 @@
+import { CSSResultGroup, LitElement, TemplateResult } from 'lit';
+export type FieldState = "empty" | "success" | "error";
+export declare abstract class FieldElement<V = unknown> extends LitElement {
+    protected static baseStyles: CSSResultGroup;
+    protected value: V;
+    connectedCallback(): void;
+    protected dispatchState(state: FieldState, message?: string): void;
+    abstract render(): TemplateResult;
+}

package/dist/src/extensions/ui/index.d.ts

@@ -0,0 +1 @@
+export { FieldElement } from './field-element';

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export { MLForm } from './mlform';

package/dist/src/mlform/index.d.ts

@@ -0,0 +1 @@
+export { MLForm } from './mlform';

package/dist/src/mlform/mlform.d.ts

@@ -0,0 +1,27 @@
+import { Signature } from '../core';
+import { Output } from '../core/domain';
+import { FieldStrategy, ReportStrategy } from '../extensions/app';
+import { IMLForm } from './mlform.types';
+import * as z from "zod";
+type SubmitCallback = (inputs: Record<string, unknown>, response: Output) => void;
+export declare class MLForm implements IMLForm {
+    private readonly backendUrl;
+    private readonly fieldService;
+    private readonly modelService;
+    private _lastInputs;
+    private _lastResponse;
+    private readonly _listeners;
+    constructor(backendUrl: string);
+    register(descriptor: FieldStrategy | ReportStrategy): void;
+    update(descriptor: FieldStrategy | ReportStrategy): void;
+    unregister(descriptor: FieldStrategy | ReportStrategy): void;
+    /** Lectura sincrónica del último envío */
+    get lastInputs(): Record<string, unknown> | null;
+    get lastResponse(): Output | null;
+    /** Suscripción reactiva; devuelve la función para des‑suscribirse */
+    onSubmit(cb: SubmitCallback): () => void;
+    toHTMLElement(data: Signature, container: HTMLElement): Promise<HTMLElement>;
+    validateSchema(data: Signature): Promise<unknown>;
+    schema(): z.core.JSONSchema.JSONSchema;
+}
+export {};

package/dist/src/mlform/mlform.types.d.ts

@@ -0,0 +1,11 @@
+import { Signature } from '../core/domain';
+import { FieldStrategy, ReportStrategy } from '../extensions/app';
+export interface IMLForm {
+    register(descriptor: FieldStrategy): void;
+    register(descriptor: ReportStrategy): void;
+    update(descriptor: FieldStrategy): void;
+    update(descriptor: ReportStrategy): void;
+    unregister(descriptor: FieldStrategy): void;
+    unregister(descriptor: ReportStrategy): void;
+    toHTMLElement(data: Signature, container: HTMLElement): Promise<HTMLElement>;
+}

package/dist/src/strategies/app/BooleanStrategy.d.ts

@@ -0,0 +1,12 @@
+import { Infer } from '../../core/domain';
+import { FieldStrategy } from '../../extensions/app';
+import { BooleanFieldSchema } from '../domain';
+export declare class BooleanStrategy extends FieldStrategy<typeof BooleanFieldSchema> {
+    constructor();
+    protected buildControl(field: Infer<typeof BooleanFieldSchema>): {
+        tag: string;
+        props: {
+            defaultValue: string | undefined;
+        };
+    };
+}

package/dist/src/strategies/app/CategoryStrategy.d.ts

@@ -0,0 +1,13 @@
+import { Infer } from '../../core/domain';
+import { FieldStrategy } from '../../extensions/app';
+import { CategoryFieldSchema } from '../domain';
+export declare class CategoryStrategy extends FieldStrategy<typeof CategoryFieldSchema> {
+    constructor();
+    protected buildControl(field: Infer<typeof CategoryFieldSchema>): {
+        tag: string;
+        props: {
+            defaultValue: string;
+            optionList: string[];
+        };
+    };
+}

package/dist/src/strategies/app/ClassifierStrategy.d.ts

@@ -0,0 +1,15 @@
+import { Infer } from '../../core/domain';
+import { ReportStrategy } from '../../extensions/app';
+import { ClassifierModelSchema } from '../domain';
+export declare class ClassifierStrategy extends ReportStrategy<typeof ClassifierModelSchema> {
+    constructor();
+    buildControl(model: Infer<typeof ClassifierModelSchema>): {
+        tag: string;
+        props: {
+            title: string | undefined;
+            mapping: string[] | undefined;
+            probabilities: number[][] | undefined;
+            details: string;
+        };
+    };
+}

package/dist/src/strategies/app/DateStrategy.d.ts

@@ -0,0 +1,15 @@
+import { Infer } from '../../core/domain';
+import { FieldStrategy } from '../../extensions/app';
+import { DateFieldSchema } from '../domain';
+export declare class DateStrategy extends FieldStrategy<typeof DateFieldSchema> {
+    constructor();
+    buildControl(field: Infer<typeof DateFieldSchema>): {
+        tag: string;
+        props: {
+            min: string | undefined;
+            max: string | undefined;
+            step: number | undefined;
+            defaultValue: string | undefined;
+        };
+    };
+}

package/dist/src/strategies/app/NumberStrategy.d.ts

@@ -0,0 +1,29 @@
+import { Infer } from '../../core/domain';
+import { FieldStrategy } from '../../extensions/app';
+import { NumberFieldSchema } from '../domain';
+export declare class NumberStrategy extends FieldStrategy<typeof NumberFieldSchema> {
+    constructor();
+    buildControl(field: Infer<typeof NumberFieldSchema>): {
+        tag: string;
+        props: {
+            unit: string | undefined;
+            min: number | undefined;
+            max: number | undefined;
+            step: number | undefined;
+            defaultValue: number | undefined;
+            placeholder?: undefined;
+        };
+        slot: string;
+    } | {
+        tag: string;
+        props: {
+            unit: string | undefined;
+            min: number | undefined;
+            max: number | undefined;
+            step: number | undefined;
+            defaultValue: number | undefined;
+            placeholder: string | undefined;
+        };
+        slot?: undefined;
+    };
+}

package/dist/src/strategies/app/RegressorStrategy.d.ts

@@ -0,0 +1,15 @@
+import { Infer } from '../../core/domain';
+import { ReportStrategy } from '../../extensions/app';
+import { RegressorModelSchema } from '../domain';
+export declare class RegressorStrategy extends ReportStrategy<typeof RegressorModelSchema> {
+    constructor();
+    buildControl(model: Infer<typeof RegressorModelSchema>): {
+        tag: string;
+        props: {
+            title: string | undefined;
+            values: number[] | undefined;
+            unit: string | undefined;
+            interval: [number, number] | undefined;
+        };
+    };
+}

package/dist/src/strategies/app/TextStrategy.d.ts

@@ -0,0 +1,16 @@
+import { Infer } from '../../core/domain';
+import { FieldStrategy } from '../../extensions/app';
+import { TextFieldSchema } from '../domain';
+export declare class TextStrategy extends FieldStrategy<typeof TextFieldSchema> {
+    constructor();
+    buildControl(field: Infer<typeof TextFieldSchema>): {
+        tag: string;
+        props: {
+            minlength: number | undefined;
+            maxlength: number | undefined;
+            placeholder: string | undefined;
+            defaultValue: string | undefined;
+            pattern: string | undefined;
+        };
+    };
+}