@distilled.cloud/stackit 0.0.0-stage → 1.0.0-rc.14

package/package.json

@@ -1,6 +1,88 @@
 {
   "name": "@distilled.cloud/stackit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-rc.14",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alchemy-run/distilled",
+    "directory": "packages/stackit"
+  },
+  "files": [
+    "lib",
+    "src"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "module": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "bun": "./src/index.ts",
+      "worker": "./src/index.ts",
+      "default": "./lib/index.js"
+    },
+    "./Credentials": {
+      "types": "./lib/credentials.d.ts",
+      "bun": "./src/credentials.ts",
+      "worker": "./src/credentials.ts",
+      "default": "./lib/credentials.js"
+    },
+    "./Errors": {
+      "types": "./lib/errors.d.ts",
+      "bun": "./src/errors.ts",
+      "worker": "./src/errors.ts",
+      "default": "./lib/errors.js"
+    },
+    "./Pagination": {
+      "types": "./lib/pagination.d.ts",
+      "bun": "./src/pagination.ts",
+      "worker": "./src/pagination.ts",
+      "default": "./lib/pagination.js"
+    },
+    "./Protocol": {
+      "types": "./lib/protocol.d.ts",
+      "bun": "./src/protocol.ts",
+      "worker": "./src/protocol.ts",
+      "default": "./lib/protocol.js"
+    },
+    "./Retry": {
+      "types": "./lib/retry.d.ts",
+      "bun": "./src/retry.ts",
+      "worker": "./src/retry.ts",
+      "default": "./lib/retry.js"
+    },
+    "./Traits": {
+      "types": "./lib/traits.d.ts",
+      "bun": "./src/traits.ts",
+      "worker": "./src/traits.ts",
+      "default": "./lib/traits.js"
+    },
+    "./*": {
+      "types": "./lib/services/*.d.ts",
+      "bun": "./src/services/*.ts",
+      "worker": "./src/services/*.ts",
+      "default": "./lib/services/*.js"
+    }
+  },
+  "dependencies": {
+    "@distilled.cloud/core": "1.0.0-rc.14"
+  },
+  "devDependencies": {
+    "@types/node": "26.2.0"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0"
+  },
+  "distilled": {
+    "generatedAt": "2026-10-06",
+    "specUpdatedAt": "2026-10-03"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "convert": "node --conditions=bun scripts/convert.ts",
+    "generate": "node --conditions=bun scripts/generate.ts",
+    "typecheck": "tsc -p tsconfig.json",
+    "specs:fetch": "git submodule update --force --init --depth=1 specs/spec-mirror-stackit",
+    "specs:update": "git submodule update --remote --force --depth=1 specs/spec-mirror-stackit"
+  }
 }

package/src/credentials.ts

@@ -0,0 +1,84 @@
+import { ConfigError } from "@distilled.cloud/core/errors";
+/**
+ * STACKIT credentials — hand-written.
+ *
+ * The `Credentials` service resolves `{ token, region }` per request; the
+ * protocol layer formats the `Authorization: Bearer <token>` header from it
+ * and rewrites each operation's spec `servers` URL for the region. The token
+ * is a STACKIT service-account access token — the same value the official
+ * Go SDK, CLI and Terraform provider read from
+ * `STACKIT_SERVICE_ACCOUNT_TOKEN`. Key-file exchange
+ * (`STACKIT_SERVICE_ACCOUNT_KEY_PATH`) is not modelled: mint the token
+ * outside the SDK.
+ *
+ * Each STACKIT product has its own host (`iaas.api.eu01.stackit.cloud`,
+ * `ske.api.eu01.stackit.cloud`, …). The per-operation host is baked into
+ * the generated `T.Http` trait from the OpenAPI `servers` entry; `region`
+ * (default `eu01`) is substituted at request time. An explicit `apiBaseUrl`
+ * overrides that host for every call — a proxy, not a per-product map.
+ */
+import * as EffectConfig from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+
+/** STACKIT's primary public region (Schwarz IT / Germany). */
+export const DEFAULT_REGION = "eu01";
+
+export interface Config {
+  readonly token: Redacted.Redacted<string>;
+  /**
+   * Region inserted into product hosts (`eu01` →
+   * `https://iaas.api.eu01.stackit.cloud`). `"global"` leaves the spec URL
+   * unchanged.
+   */
+  readonly region: string;
+  /** When set, every operation uses this host instead of the spec's. */
+  readonly apiBaseUrl?: string;
+}
+
+export class Credentials extends Context.Service<Credentials, Effect.Effect<Config>>()(
+  "StackitCredentials",
+) {}
+
+const envConfig = EffectConfig.all({
+  // `STACKIT_SERVICE_ACCOUNT_TOKEN` / `STACKIT_REGION` are what the
+  // official Go SDK, CLI and Terraform provider read.
+  token: EffectConfig.String("STACKIT_SERVICE_ACCOUNT_TOKEN"),
+  region: EffectConfig.String("STACKIT_REGION").pipe(EffectConfig.withDefault(DEFAULT_REGION)),
+  apiBaseUrl: EffectConfig.String("STACKIT_API_BASE_URL").pipe(EffectConfig.option),
+});
+
+export const CredentialsFromEnv = Layer.succeed(
+  Credentials,
+  envConfig.pipe(
+    Effect.mapError(
+      () =>
+        new ConfigError({
+          message: "STACKIT_SERVICE_ACCOUNT_TOKEN environment variable is required",
+        }),
+    ),
+    Effect.map(({ token, region, apiBaseUrl }) => ({
+      token: Redacted.make(token),
+      region,
+      apiBaseUrl: apiBaseUrl._tag === "Some" ? apiBaseUrl.value : undefined,
+    })),
+    Effect.orDie,
+  ),
+);
+
+/** Convenience layer from a redacted token + optional region / base URL. */
+export const credentials = (config: {
+  readonly token: Redacted.Redacted<string>;
+  readonly region?: string;
+  readonly apiBaseUrl?: string;
+}): Layer.Layer<Credentials> =>
+  Layer.succeed(
+    Credentials,
+    Effect.succeed({
+      token: config.token,
+      region: config.region ?? DEFAULT_REGION,
+      apiBaseUrl: config.apiBaseUrl,
+    }),
+  );

package/src/errors.ts

@@ -0,0 +1,50 @@
+/**
+ * STACKIT-specific error types.
+ *
+ * Re-exports the common HTTP errors from core and adds the unknown-error
+ * and parse-error wrappers. STACKIT failures carry `{ message, error? }`
+ * (the `ErrorMessage` schema in most of the product specs); the protocol
+ * reads `message` for the human half and `error` as the machine-readable
+ * code on {@link UnknownStackitError}.
+ */
+export {
+  BadGateway,
+  BadRequest,
+  Conflict,
+  ConfigError,
+  Forbidden,
+  GatewayTimeout,
+  InternalServerError,
+  Locked,
+  NotFound,
+  ServiceUnavailable,
+  TooManyRequests,
+  Unauthorized,
+  UnprocessableEntity,
+  HTTP_STATUS_MAP,
+  DEFAULT_ERRORS,
+  API_ERRORS,
+} from "@distilled.cloud/core/errors";
+export type { DefaultErrors } from "@distilled.cloud/core/errors";
+
+import * as Category from "@distilled.cloud/core/category";
+import * as Schema from "effect/Schema";
+
+/** Unknown STACKIT error — returned when nothing else matches the failure. */
+export class UnknownStackitError extends Schema.TaggedError<UnknownStackitError>()(
+  "UnknownStackitError",
+  {
+    code: Schema.optional(Schema.String),
+    message: Schema.optional(Schema.String),
+    body: Schema.Unknown,
+  },
+).pipe(Category.withServerError) {}
+
+/** Schema parse error wrapper. */
+export class StackitParseError extends Schema.TaggedError<StackitParseError>()(
+  "StackitParseError",
+  {
+    body: Schema.Unknown,
+    cause: Schema.Unknown,
+  },
+).pipe(Category.withParseError) {}

package/src/index.ts

@@ -0,0 +1,34 @@
+/**
+ * @distilled.cloud/stackit — STACKIT Cloud API SDK for Effect.
+ *
+ * `./services` is generated by `scripts/generate.ts` from the Smithy models
+ * in `.generated-specs` (written by `scripts/convert.ts` from the OpenAPI
+ * documents mirrored at `specs/spec-mirror-stackit/specs/`). Everything else
+ * in this folder is hand-written.
+ *
+ * One module per STACKIT product (IaaS, SKE, DNS, Postgres Flex, …), using
+ * that product's latest published OpenAPI version. Auth is a service-account
+ * bearer token (`STACKIT_SERVICE_ACCOUNT_TOKEN`); each product's host is
+ * rewritten for `STACKIT_REGION` (default `eu01`).
+ *
+ * @example
+ * ```ts
+ * import * as Stackit from "@distilled.cloud/stackit";
+ *
+ * const { zones } = yield* Stackit.dns.listZones({
+ *   projectId: "...",
+ * });
+ * ```
+ */
+export * from "./credentials.ts";
+export * from "./errors.ts";
+export * as T from "./traits.ts";
+export {
+  StackitProtocol,
+  applyRegion,
+  type StackitOpError,
+  type StackitOpContext,
+} from "./protocol.ts";
+export { paginateByTotalPages } from "./pagination.ts";
+export * as Retry from "./retry.ts";
+export * from "./services/index.ts";

package/src/pagination.ts

@@ -0,0 +1,57 @@
+import { getPath, type PaginationStrategy } from "@distilled.cloud/core/pagination";
+/**
+ * STACKIT pagination — hand-written.
+ *
+ * Several STACKIT list operations page by NUMBER: `?page=N&pageSize=M` in,
+ * and a response carrying the collection beside `totalPages` (DNS zones /
+ * record sets, and the same envelope on other products). Core's
+ * `paginatePageNumber` treats `outputToken` as the NEXT page number, so
+ * pointing it at `totalPages` would jump to the last page; this strategy
+ * advances by one until `page >= totalPages`.
+ */
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+export type { PaginatedTrait, PaginationStrategy } from "@distilled.cloud/core/pagination";
+
+/**
+ * Stream of pages using STACKIT's `page` / `totalPages` envelope: request
+ * `page`, `page+1`, … while `page < totalPages` and the collection is
+ * non-empty.
+ */
+export const paginateByTotalPages: PaginationStrategy = (operation, input, pagination) => {
+  const inputToken = pagination.inputToken;
+  const totalPagesPath = pagination.outputToken;
+  const itemsPath = pagination.items;
+  if (!inputToken || !totalPagesPath) {
+    return Stream.die(
+      new Error("Total-pages pagination requires inputToken and outputToken (totalPages)"),
+    );
+  }
+
+  type State = { page: number; done: boolean };
+  const startPage = typeof input[inputToken] === "number" ? (input[inputToken] as number) : 1;
+
+  return Stream.unfold({ page: startPage, done: false } as State, (state) =>
+    Effect.gen(function* () {
+      if (state.done) return undefined;
+
+      const requestPayload = {
+        ...input,
+        [inputToken]: state.page,
+      } as typeof input;
+      const response = yield* operation(requestPayload);
+
+      const totalPages = getPath(response, totalPagesPath);
+      const items = itemsPath
+        ? (getPath(response, itemsPath) as readonly unknown[] | undefined)
+        : undefined;
+      const exhausted =
+        typeof totalPages !== "number" ||
+        state.page >= totalPages ||
+        (items !== undefined && items.length === 0);
+
+      return [response, { page: state.page + 1, done: exhausted } satisfies State] as const;
+    }),
+  );
+};

package/src/protocol.test.ts

@@ -0,0 +1,304 @@
+import * as CoreErrors from "@distilled.cloud/core/errors";
+import * as ResponseValidation from "@distilled.cloud/core/response-validation";
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { describe, expect, test } from "vitest";
+import { Credentials, credentials } from "./credentials.ts";
+import { StackitParseError, UnknownStackitError } from "./errors.ts";
+import { applyRegion } from "./protocol.ts";
+import * as Retry from "./retry.ts";
+import { listServers } from "./services/iaas.ts";
+import {
+  BadRequest,
+  Conflict,
+  deleteProject,
+  getProject,
+  listProjects,
+  NotFound,
+} from "./services/resource_manager.ts";
+import { getInstance } from "./services/secrets_manager.ts";
+
+interface Captured {
+  readonly method: string;
+  readonly url: URL;
+  readonly headers: Record<string, string>;
+  readonly body: string | undefined;
+}
+
+const fakeStackit = (
+  status = 200,
+  body: string | null = "{}",
+  headers: Record<string, string> = {},
+) => {
+  const calls: Captured[] = [];
+  const layer = Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request, url) =>
+      Effect.sync(() => {
+        calls.push({
+          method: request.method,
+          url,
+          headers: { ...request.headers },
+          body:
+            request.body._tag === "Uint8Array"
+              ? new TextDecoder().decode(request.body.body)
+              : undefined,
+        });
+        return HttpClientResponse.fromWeb(request, new Response(body, { status, headers }));
+      }),
+    ),
+  );
+  return { calls, layer };
+};
+
+const creds = (config: { region?: string; apiBaseUrl?: string } = {}) =>
+  credentials({ token: Redacted.make("stackit-token"), ...config });
+
+const run = <A, E>(
+  operation: Effect.Effect<A, E, Credentials | HttpClient.HttpClient>,
+  http: Layer.Layer<HttpClient.HttpClient>,
+  credentialsLayer: Layer.Layer<Credentials> = creds(),
+) =>
+  Effect.runPromise(
+    operation.pipe(Retry.none, Effect.provide(credentialsLayer), Effect.provide(http)),
+  );
+
+const runFlip = <A, E>(
+  operation: Effect.Effect<A, E, Credentials | HttpClient.HttpClient>,
+  http: Layer.Layer<HttpClient.HttpClient>,
+) =>
+  Effect.runPromise(
+    operation.pipe(Retry.none, Effect.provide(creds()), Effect.provide(http), Effect.flip),
+  );
+
+const projectId = "11111111-2222-3333-4444-555555555555";
+
+describe("applyRegion", () => {
+  test("inserts the region into a version-less product host", () => {
+    expect(applyRegion("https://ske.api.stackit.cloud", "eu01")).toBe(
+      "https://ske.api.eu01.stackit.cloud",
+    );
+    expect(applyRegion("https://load-balancer.api.stackit.cloud/", "eu02")).toBe(
+      "https://load-balancer.api.eu02.stackit.cloud/",
+    );
+  });
+
+  test("substitutes a glued {region} template, adding the trailing dot", () => {
+    expect(applyRegion("https://argus.api.{region}stackit.cloud", "eu01")).toBe(
+      "https://argus.api.eu01.stackit.cloud",
+    );
+    expect(applyRegion("https://argus.api.{region}stackit.cloud", "eu01.")).toBe(
+      "https://argus.api.eu01.stackit.cloud",
+    );
+  });
+
+  test("substitutes a non-glued {region} template verbatim", () => {
+    expect(applyRegion("https://example.{region}.stackit.cloud", "eu01")).toBe(
+      "https://example.eu01.stackit.cloud",
+    );
+  });
+
+  test("'global' leaves hosts alone and drops a leftover {region}", () => {
+    expect(applyRegion("https://dns.api.stackit.cloud", "global")).toBe(
+      "https://dns.api.stackit.cloud",
+    );
+    expect(applyRegion("https://argus.api.{region}stackit.cloud", "global")).toBe(
+      "https://argus.api.stackit.cloud",
+    );
+  });
+
+  test("leaves non-STACKIT and already-regional hosts alone", () => {
+    expect(applyRegion("https://proxy.example.com", "eu01")).toBe("https://proxy.example.com");
+    expect(applyRegion("https://ske.api.eu01.stackit.cloud", "eu02")).toBe(
+      "https://ske.api.eu01.stackit.cloud",
+    );
+  });
+});
+
+describe("request encoding", () => {
+  test("sends Bearer auth to the product host in the default region (eu01)", async () => {
+    const { calls, layer } = fakeStackit(200, JSON.stringify({}));
+    await run(getProject({ id: projectId }), layer);
+    expect(calls[0].headers.authorization).toBe("Bearer stackit-token");
+    expect(calls[0].url.href).toBe(
+      `https://resource-manager.api.eu01.stackit.cloud/v2/projects/${projectId}`,
+    );
+  });
+
+  test("each product uses its own host; the configured region is applied", async () => {
+    const iaas = fakeStackit(200, JSON.stringify({ items: [] }));
+    await run(
+      listServers({ projectId, region: "eu02", details: true }),
+      iaas.layer,
+      creds({ region: "eu02" }),
+    );
+    expect(iaas.calls[0].url.href).toBe(
+      `https://iaas.api.eu02.stackit.cloud/v2/projects/${projectId}/regions/eu02/servers?details=true`,
+    );
+
+    const secrets = fakeStackit(200, JSON.stringify({}));
+    await run(
+      getInstance({ projectId, instanceId: "i-1" }),
+      secrets.layer,
+      creds({ region: "eu02" }),
+    );
+    expect(secrets.calls[0].url.href).toBe(
+      `https://secrets-manager.api.eu02.stackit.cloud/v1/projects/${projectId}/instances/i-1`,
+    );
+  });
+
+  test("region 'global' keeps the spec host", async () => {
+    const { calls, layer } = fakeStackit(200, JSON.stringify({}));
+    await run(getProject({ id: projectId }), layer, creds({ region: "global" }));
+    expect(calls[0].url.origin).toBe("https://resource-manager.api.stackit.cloud");
+  });
+
+  test("an explicit apiBaseUrl overrides every product host", async () => {
+    const { calls, layer } = fakeStackit(200, JSON.stringify({}));
+    await run(
+      getInstance({ projectId, instanceId: "i-1" }),
+      layer,
+      creds({ apiBaseUrl: "http://localhost:8080" }),
+    );
+    expect(calls[0].url.href).toBe(`http://localhost:8080/v1/projects/${projectId}/instances/i-1`);
+  });
+
+  test("resolves credentials per request", async () => {
+    const { calls, layer } = fakeStackit(200, JSON.stringify({}));
+    let n = 0;
+    const rotating = Layer.succeed(
+      Credentials,
+      Effect.sync(() => ({ token: Redacted.make(`t${++n}`), region: n === 1 ? "eu01" : "eu02" })),
+    );
+    await run(getProject({ id: projectId }), layer, rotating);
+    await run(getProject({ id: projectId }), layer, rotating);
+    expect(calls.map((c) => [c.headers.authorization, c.url.host])).toEqual([
+      ["Bearer t1", "resource-manager.api.eu01.stackit.cloud"],
+      ["Bearer t2", "resource-manager.api.eu02.stackit.cloud"],
+    ]);
+  });
+
+  test("labels are encoded; array queries repeat; wire query names are used", async () => {
+    const get = fakeStackit(200, JSON.stringify({}));
+    await run(getProject({ id: "a b/c" }), get.layer);
+    expect(get.calls[0].url.pathname).toBe("/v2/projects/a%20b%2Fc");
+
+    const list = fakeStackit(200, JSON.stringify({ items: [] }));
+    await run(
+      listProjects({
+        containerIds: ["p1", "p2"],
+        limit: 10,
+        creation_time_start: "2024-01-01T00:00:00Z",
+      }),
+      list.layer,
+    );
+    const url = list.calls[0].url;
+    expect(url.searchParams.getAll("containerIds")).toEqual(["p1", "p2"]);
+    expect(url.searchParams.get("limit")).toBe("10");
+    expect(url.searchParams.get("creation-time-start")).toBe("2024-01-01T00:00:00Z");
+  });
+});
+
+describe("{ message, error } failure envelope", () => {
+  test("a declared status class carries `message`", async () => {
+    const { layer } = fakeStackit(
+      404,
+      JSON.stringify({ message: "project not found", error: "Not Found" }),
+    );
+    const error = await runFlip(getProject({ id: projectId }), layer);
+    expect(error).toBeInstanceOf(NotFound);
+    expect(error).toMatchObject({ message: "project not found" });
+  });
+
+  test("409 matches the declared Conflict", async () => {
+    const { layer } = fakeStackit(
+      409,
+      JSON.stringify({ message: "has children", error: "Conflict" }),
+    );
+    const error = await runFlip(deleteProject({ id: projectId }), layer);
+    expect(error).toBeInstanceOf(Conflict);
+  });
+
+  test("400 matches the declared BadRequest", async () => {
+    const { layer } = fakeStackit(
+      400,
+      JSON.stringify({ message: "bad limit", error: "Bad Request" }),
+    );
+    const error = await runFlip(listProjects({ limit: -1 }), layer);
+    expect(error).toBeInstanceOf(BadRequest);
+    expect(error).toMatchObject({ message: "bad limit" });
+  });
+
+  test("undeclared statuses fall back to the core HTTP classes with Retry-After", async () => {
+    const { layer } = fakeStackit(429, JSON.stringify({ message: "slow down" }), {
+      "retry-after": "4",
+    });
+    const error = await runFlip(getProject({ id: projectId }), layer);
+    expect(error).toBeInstanceOf(CoreErrors.TooManyRequests);
+    expect(error).toMatchObject({ message: "slow down" });
+    expect((error as CoreErrors.TooManyRequests).retryAfter).toBeDefined();
+  });
+
+  test("unmapped 5xx becomes InternalServerError; plain text is the message", async () => {
+    const { layer } = fakeStackit(507, "  insufficient storage\n");
+    const error = await runFlip(getProject({ id: projectId }), layer);
+    expect(error).toBeInstanceOf(CoreErrors.InternalServerError);
+    expect(error).toMatchObject({ message: "insufficient storage" });
+  });
+
+  test("an empty body uses `HTTP <status>` as message", async () => {
+    const { layer } = fakeStackit(404, "");
+    const error = await runFlip(getProject({ id: projectId }), layer);
+    expect(error).toBeInstanceOf(NotFound);
+    expect(error).toMatchObject({ message: "HTTP 404" });
+  });
+
+  test("unmapped 4xx becomes UnknownStackitError with `error` as code", async () => {
+    const body = { message: "teapot", error: "I'm a teapot" };
+    const { layer } = fakeStackit(418, JSON.stringify(body));
+    const error = await runFlip(getProject({ id: projectId }), layer);
+    expect(error).toBeInstanceOf(UnknownStackitError);
+    expect(error).toMatchObject({ code: "I'm a teapot", message: "teapot", body });
+  });
+
+  test("a numeric `code` is stringified when `error` is absent", async () => {
+    const body = { message: "teapot", code: 4180 };
+    const { layer } = fakeStackit(418, JSON.stringify(body));
+    const error = await runFlip(getProject({ id: projectId }), layer);
+    expect(error).toBeInstanceOf(UnknownStackitError);
+    expect(error).toMatchObject({ code: "4180", message: "teapot" });
+  });
+});
+
+describe("success decoding", () => {
+  test("the 2xx JSON body is the payload; empty bodies decode to {}", async () => {
+    const project = { containerId: "c", projectId, name: "p" };
+    const get = fakeStackit(200, JSON.stringify(project));
+    expect(await run(getProject({ id: projectId }), get.layer)).toEqual(project);
+
+    for (const [status, body] of [
+      [202, ""],
+      [204, null],
+    ] as const) {
+      const del = fakeStackit(status, body);
+      expect(await run(deleteProject({ id: projectId }), del.layer)).toEqual({});
+    }
+  });
+
+  test("strict validation fails a mismatched payload with StackitParseError", async () => {
+    const { layer } = fakeStackit(200, JSON.stringify({ name: 42 }));
+    const error = await Effect.runPromise(
+      getProject({ id: projectId }).pipe(
+        Retry.none,
+        Effect.provide(creds()),
+        Effect.provide(layer),
+        Effect.provide(ResponseValidation.strict),
+        Effect.flip,
+      ),
+    );
+    expect(error).toBeInstanceOf(StackitParseError);
+  });
+});