@missioncontrolio/client 0.0.3

package/.env.local.example

@@ -0,0 +1,9 @@
+MC_TENANT_ID=<your-azure-ad-tenant-id>
+MC_CLIENT_ID=<your-client-id>
+MC_CLIENT_SECRET=<your-client-secret>
+MC_PARTNER_ID=<your-partner-id>
+MC_BASE_URL=https://api.sandbox.missioncontrol.io
+MC_SCOPE=api://<app-id>/.default
+MC_PRODUCT_ID=<your-product-id>
+MC_REGION_ID=<your-region-id>
+MC_PUBLISHER_ID=<your-publisher-id>

package/README.md

@@ -0,0 +1,226 @@
+# MissionControl Client — Node SDK
+
+The Node SDK for the [Mission:Control](https://www.missioncontrol.io) Partner API. Built on top of [Kiota](https://learn.microsoft.com/en-us/openapi/kiota/), it provides a strongly-typed, async client for all partner operations: listing products, managing reservations, and creating orders.
+
+## Requirements
+
+Node.js 18 or later
+
+## Installation
+
+```
+npm install @pandomc/missioncontrol-client
+```
+
+## Getting started
+
+### Creating a client
+
+Credentials are obtained from the **Client Credentials** page in the Mission:Control portal.
+
+```ts
+import { ClientBuilder } from "@pandomc/missioncontrol-client";
+
+const client = new ClientBuilder()
+  .withAzureAdClientCredentials("your-client-id", "your-client-secret")
+  .withDefaultPartnerId("your-partner-id")
+  .build();
+```
+
+By default the client targets **Production**. To use the **Sandbox** environment during development:
+
+```ts
+import {
+  ClientBuilder,
+  MissionControlEnvironment,
+} from "@pandomc/missioncontrol-client";
+
+const client = new ClientBuilder()
+  .forEnvironment(MissionControlEnvironment.Sandbox)
+  .withAzureAdClientCredentials("your-client-id", "your-client-secret")
+  .withDefaultPartnerId("your-partner-id")
+  .build();
+```
+
+## Usage examples
+
+### List products
+
+```ts
+const result = await client.product.get();
+
+for (const product of result?.result ?? []) {
+  console.log(product.id, product.name);
+}
+```
+
+### Check stock
+
+```ts
+const response = await client.product.hasStock.post({
+  productId: productId,
+  regionId: regionId,
+});
+
+console.log(response?.hasStock ? "In stock" : "Out of stock");
+```
+
+### Reserve → claim (place an order)
+
+```ts
+// 1. Create a reservation — holds the key briefly while the customer checks out.
+const reservation = await client.reservation.post({
+  productId: productId,
+  regionId: regionId,
+});
+
+// 2. Claim the reservation to finalise the order and receive the key.
+const order = await client.order.claimReservation
+  .byReservationId(reservation!.id!)
+  .post({
+    requestId: crypto.randomUUID(),
+    partnerReference: "your-internal-order-ref",
+    invoiceDate: new Date().toISOString(),
+    salesChannel: [],
+    endConsumer: {
+      ipAddress: "1.2.3.4",
+      language: "en-US",
+      location: { countryCode: "NL" },
+    },
+    salesPrice: {
+      priceIncludingVat: { value: 9.99, currencyCode: "EUR" },
+      vatDetail: { rate: 21 },
+    },
+  });
+
+console.log(`Order ${order!.id} placed.`);
+```
+
+### Cancel a reservation
+
+```ts
+await client.reservation.byReservationId(reservation!.id!).cancel.post();
+```
+
+### Filtering and pagination
+
+All list endpoints accept an optional `queryParameters` object for filtering and pagination. Every parameter is optional — only set what you need.
+
+**Filter products by publisher, name, and page size:**
+
+```ts
+const result = await client.product.get({
+  queryParameters: {
+    publisherId: ["publisher-id-1", "publisher-id-2"],
+    name: "minecraft",
+    pageSize: 25,
+    pageIndex: 0,
+  },
+});
+```
+
+## Configuration reference
+
+| Key            | Required | Description                                                 |
+| -------------- | -------- | ----------------------------------------------------------- |
+| `clientId`     | ✓        | Application (client) ID from the portal                     |
+| `clientSecret` | ✓        | Client secret from the portal                               |
+| `partnerId`    | ✓        | Partner ID sent as `X-Partner-Id` with every request        |
+| `environment`  | —        | `Sandbox` or `Production` (default: `Production`)           |
+| `tenantId`     | —        | Azure AD tenant ID (defaults to the Mission:Control tenant) |
+
+### `ClientBuilder` methods
+
+| Method                                                            | Description                                        |
+| ----------------------------------------------------------------- | -------------------------------------------------- |
+| `withAzureAdClientCredentials(clientId, clientSecret, tenantId?)` | Configure authentication                           |
+| `withDefaultPartnerId(partnerId)`                                 | Set the `X-Partner-Id` header for every request    |
+| `forEnvironment(env)`                                             | Target `Sandbox` or `Production`                   |
+| `withBaseUrl(url)`                                                | Override the base URL (e.g. for local development) |
+| `withScope(scope)`                                                | Override the OAuth scope                           |
+| `build()`                                                         | Return the configured `Client` instance            |
+
+## Resilience
+
+The SDK registers Kiota's default HTTP middleware pipeline, which includes a `RetryHandler` that automatically retries transient failures before surfacing an exception:
+
+| Status code | Meaning             | Behaviour                             |
+| ----------- | ------------------- | ------------------------------------- |
+| `429`       | Too Many Requests   | Retried after honouring `Retry-After` |
+| `503`       | Service Unavailable | Retried with exponential back-off     |
+| `504`       | Gateway Timeout     | Retried with exponential back-off     |
+
+The handler retries up to three times by default. If all retries are exhausted without a successful response the last error response is returned to the caller (and mapped to a `ProblemDetails` error where applicable).
+
+No extra configuration is required — retries are active out of the box.
+
+## Error handling
+
+The API returns errors as [RFC 9457 Problem Details](https://www.rfc-editor.org/rfc/rfc9457) JSON objects. The SDK maps these to `ProblemDetails` objects and throws them, which you catch like any other error.
+
+### `ProblemDetails` properties
+
+| Property         | Type                      | Description                                                     |
+| ---------------- | ------------------------- | --------------------------------------------------------------- |
+| `status`         | `number \| null`          | HTTP status code (e.g. `400`, `500`)                            |
+| `title`          | `string \| null`          | Short, human-readable summary of the problem                    |
+| `detail`         | `string \| null`          | Longer explanation of this specific occurrence                  |
+| `type`           | `string \| null`          | URI identifying the problem type                                |
+| `instance`       | `string \| null`          | URI identifying this specific occurrence                        |
+| `additionalData` | `Record<string, unknown>` | Any extra fields returned by the API (e.g. `errors`, `traceId`) |
+
+### Status codes
+
+| Status | When it occurs                                                                                      |
+| ------ | --------------------------------------------------------------------------------------------------- |
+| `400`  | The request failed validation — check `additionalData["errors"]` for per-field messages             |
+| `500`  | An unexpected error occurred on the server — `additionalData["traceId"]` can be shared with support |
+
+### Handling a validation error (400)
+
+A 400 response from the API looks like:
+
+```json
+{
+  "type": "https://tools.ietf.org/html/rfc9110#section-15.5.1",
+  "title": "One or more validation errors occurred.",
+  "status": 400,
+  "errors": {
+    "ProductId": ["The value 'foobar' is not valid."]
+  },
+  "traceId": "00-90f2dadbc2e77ae87cbe3b8a25fe0689-dbff6f5f82d028d2-00"
+}
+```
+
+`errors` and `traceId` are not first-class properties on the model — they land in `additionalData` because they are not part of the OpenAPI schema. Cast them as needed:
+
+```ts
+import type { ProblemDetails } from "@pandomc/missioncontrol-client";
+
+try {
+  const result = await client.product.get({
+    queryParameters: {
+      productId: ["not-a-guid"],
+    },
+  });
+} catch (ex) {
+  if (ex && typeof ex === "object" && "status" in ex) {
+    const problem = ex as ProblemDetails;
+    console.log(`Failed: ${problem.title}`);
+
+    const errors = problem.additionalData?.["errors"];
+    if (errors && typeof errors === "object") {
+      for (const [field, messages] of Object.entries(
+        errors as Record<string, unknown>,
+      )) {
+        console.log(`  ${field}: ${messages}`);
+      }
+    }
+
+    const traceId = problem.additionalData?.["traceId"];
+    if (traceId !== undefined) {
+      console.log(`  Trace ID: ${traceId}`);
+    }
+  }
+}
+```

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@missioncontrolio/client",
+  "description": "The official Node SDK for the Mission:Control Partner API.",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run --config vitest.integration.config.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  },
+  "dependencies": {
+    "@azure/identity": "^4.13.0",
+    "@microsoft/kiota-authentication-azure": "^1.0.0-preview.100",
+    "@microsoft/kiota-bundle": "^1.0.0-preview.100"
+  },
+  "version": "0.0.3"
+}

package/src/client/autoCancelOrderHandler.ts

@@ -0,0 +1,135 @@
+import type { RequestOption } from "@microsoft/kiota-abstractions";
+import type { Middleware } from "@microsoft/kiota-http-fetchlibrary";
+import { MissionControlHeaders } from "./missionControlHeaders";
+import { nonIdempotentPaths } from "./nonIdempotentPaths";
+
+const CANCEL_TIMEOUT_MS = 30_000;
+
+/**
+ * A Kiota middleware that automatically attempts to cancel an order when a request to one of
+ * the order-mutation endpoints fails with a server error (5xx) or a network/connection error.
+ *
+ * Affected endpoints: `createOrder`, `claimReservation`, `reportOrder`.
+ *
+ * The cancellation attempt is best-effort. If it fails the original error is still propagated
+ * to the caller unchanged.
+ */
+export class AutoCancelOrderHandler implements Middleware {
+  next: Middleware | undefined;
+
+  async execute(
+    url: string,
+    requestInit: RequestInit,
+    requestOptions?: Record<string, RequestOption>,
+  ): Promise<Response> {
+    if (!isAutoCancelEndpoint(url)) {
+      return this.next!.execute(url, requestInit, requestOptions);
+    }
+
+    // Buffer the request body before the inner handler consumes it.
+    const requestBody =
+      requestInit.body != null ? String(requestInit.body) : null;
+
+    let response: Response;
+    try {
+      response = await this.next!.execute(url, requestInit, requestOptions);
+    } catch (err) {
+      // Network/connection error — attempt a best-effort cancel.
+      await this.tryCancelOrderAsync(url, requestInit, requestBody);
+      throw err;
+    }
+
+    if (isServerError(response)) {
+      await this.tryCancelOrderAsync(url, requestInit, requestBody);
+    }
+
+    return response;
+  }
+
+  private async tryCancelOrderAsync(
+    originalUrl: string,
+    originalInit: RequestInit,
+    requestBody: string | null,
+  ): Promise<void> {
+    try {
+      const requestId = extractRequestId(requestBody);
+      if (requestId == null) return;
+
+      const cancelUrl = buildCancelUrl(originalUrl);
+      if (cancelUrl == null) return;
+
+      const headers = new Headers();
+      headers.set("Content-Type", "application/json");
+
+      // Copy auth and partner-id headers so the cancel request is properly authenticated
+      // and attributed — the inner middleware handles retry and other cross-cutting concerns.
+      const originalHeaders = new Headers(originalInit.headers);
+      const auth = originalHeaders.get("Authorization");
+      if (auth) headers.set("Authorization", auth);
+      const partnerId = originalHeaders.get(MissionControlHeaders.PartnerId);
+      if (partnerId) headers.set(MissionControlHeaders.PartnerId, partnerId);
+
+      const cancelInit: RequestInit = {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ originalRequestId: requestId }),
+        signal: AbortSignal.timeout(CANCEL_TIMEOUT_MS),
+      };
+
+      await this.next!.execute(cancelUrl, cancelInit, undefined);
+    } catch {
+      // Best-effort: swallow failures so the original error propagates.
+    }
+  }
+}
+
+function isAutoCancelEndpoint(url: string): boolean {
+  try {
+    const path = new URL(url).pathname;
+    // Use includes so this works regardless of any base-path prefix
+    // (e.g. /partnerApi/v2/Order/createOrder).
+    return nonIdempotentPaths.some((prefix) =>
+      path.toLowerCase().includes(prefix.toLowerCase()),
+    );
+  } catch {
+    return false;
+  }
+}
+
+function isServerError(response: Response): boolean {
+  return response.status >= 500;
+}
+
+function extractRequestId(json: string | null): string | null {
+  if (!json) return null;
+  try {
+    const parsed: unknown = JSON.parse(json);
+    if (
+      parsed != null &&
+      typeof parsed === "object" &&
+      "requestId" in parsed &&
+      typeof (parsed as Record<string, unknown>).requestId === "string"
+    ) {
+      return (parsed as Record<string, unknown>).requestId as string;
+    }
+  } catch {
+    // Malformed body — nothing to extract.
+  }
+  return null;
+}
+
+function buildCancelUrl(url: string): string | null {
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname;
+    const orderIndex = path.toLowerCase().indexOf("/order/");
+    if (orderIndex < 0) return null;
+
+    parsed.pathname =
+      path.slice(0, orderIndex + "/Order/".length) + "cancelOrder";
+    parsed.search = "";
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}

package/src/client/clientBuilder.ts

@@ -0,0 +1,139 @@
+import { ClientSecretCredential } from "@azure/identity";
+import { AzureIdentityAuthenticationProvider } from "@microsoft/kiota-authentication-azure";
+import {
+  FetchRequestAdapter,
+  KiotaClientFactory,
+} from "@microsoft/kiota-http-fetchlibrary";
+import { createClient, type Client } from "./generated/client";
+import {
+  getBaseUrl,
+  getScope,
+  MissionControlEnvironment,
+} from "./missionControlEnvironment";
+import { createHandlers } from "./missionControlHandlers";
+
+/**
+ * Fluent builder for creating a configured {@link Client} instance.
+ */
+export class ClientBuilder {
+  private _baseUrl: string = getBaseUrl(MissionControlEnvironment.Production);
+  private _scope: string = getScope(MissionControlEnvironment.Production);
+  private _tenantId: string = "13d084c1-d072-41f2-878b-c45ca721c9f6";
+  private _clientId?: string;
+  private _clientSecret?: string;
+  private _defaultPartnerId?: string;
+
+  /**
+   * Sets the default `X-Partner-Id` header value sent with every request.
+   *
+   * Most partners operate under a single partner identity, so setting this once on the
+   * builder means you never have to specify it per-request. When a request explicitly sets
+   * the header that value takes precedence over the default configured here.
+   *
+   * @param partnerId The partner ID shown on the client credentials page in the portal.
+   */
+  withDefaultPartnerId(partnerId: string): this {
+    if (!partnerId?.trim())
+      throw new Error("partnerId must not be null or whitespace.");
+    this._defaultPartnerId = partnerId;
+    return this;
+  }
+
+  /**
+   * Overrides the base URL used for all API requests.
+   * Useful for pointing at a local development server or a custom endpoint.
+   * When combined with {@link forEnvironment}, the last call wins.
+   *
+   * @param baseUrl The base URL, e.g. `http://localhost:5000`.
+   */
+  withBaseUrl(baseUrl: string): this {
+    if (!baseUrl?.trim())
+      throw new Error("baseUrl must not be null or whitespace.");
+    this._baseUrl = baseUrl;
+    return this;
+  }
+
+  /**
+   * Overrides the OAuth scope used when acquiring tokens.
+   * Useful when running against a local or custom environment whose app registration
+   * differs from the well-known environments.
+   * When combined with {@link forEnvironment}, the last call wins.
+   *
+   * @param scope The full scope URI, e.g. `api://<app-id>/.default`.
+   */
+  withScope(scope: string): this {
+    if (!scope?.trim())
+      throw new Error("scope must not be null or whitespace.");
+    this._scope = scope;
+    return this;
+  }
+
+  /**
+   * Targets a well-known MissionControl environment. Sets the matching base URL and API scope together.
+   * Defaults to {@link MissionControlEnvironment.Production} when not called.
+   *
+   * @param environment The target environment.
+   */
+  forEnvironment(environment: MissionControlEnvironment): this {
+    this._baseUrl = getBaseUrl(environment);
+    this._scope = getScope(environment);
+    return this;
+  }
+
+  /**
+   * Configures the client to authenticate using Azure AD client credentials (client secret flow).
+   * The API scope is derived from the configured environment unless overridden by {@link withScope}.
+   *
+   * @param clientId The application (client) ID of the app registration.
+   * @param clientSecret The client secret of the app registration.
+   * @param tenantId The Azure AD tenant ID. Uses the PandoMC tenant when omitted.
+   */
+  withAzureAdClientCredentials(
+    clientId: string,
+    clientSecret: string,
+    tenantId?: string,
+  ): this {
+    this._clientId = clientId;
+    this._clientSecret = clientSecret;
+    if (tenantId) this._tenantId = tenantId;
+    return this;
+  }
+
+  /**
+   * Builds and returns the configured {@link Client}.
+   *
+   * @throws {Error} When credentials have not been configured via {@link withAzureAdClientCredentials}.
+   */
+  build(): Client {
+    if (!this._clientId || !this._clientSecret) {
+      throw new Error(
+        "No credentials configured. " +
+          "Call withAzureAdClientCredentials() before calling build().",
+      );
+    }
+
+    const credential = new ClientSecretCredential(
+      this._tenantId,
+      this._clientId,
+      this._clientSecret,
+    );
+    const allowedHosts = new Set([new URL(this._baseUrl).host]);
+    const authProvider = new AzureIdentityAuthenticationProvider(
+      credential,
+      [this._scope],
+      undefined,
+      allowedHosts,
+    );
+
+    const middlewares = createHandlers(this._defaultPartnerId);
+    const httpClient = KiotaClientFactory.create(undefined, middlewares);
+    const adapter = new FetchRequestAdapter(
+      authProvider,
+      undefined,
+      undefined,
+      httpClient,
+    );
+    adapter.baseUrl = this._baseUrl;
+    return createClient(adapter);
+  }
+}

package/src/client/generated/client.ts

@@ -0,0 +1,130 @@
+/* tslint:disable */
+/* eslint-disable */
+// Generated by Microsoft Kiota
+// @ts-ignore
+import { OrderRequestBuilderNavigationMetadata, OrderRequestBuilderRequestsMetadata, type OrderRequestBuilder } from './order/index.js';
+// @ts-ignore
+import { PartnerRequestBuilderRequestsMetadata, type PartnerRequestBuilder } from './partner/index.js';
+// @ts-ignore
+import { PriceListRequestBuilderRequestsMetadata, type PriceListRequestBuilder } from './priceList/index.js';
+// @ts-ignore
+import { ProductRequestBuilderNavigationMetadata, ProductRequestBuilderRequestsMetadata, type ProductRequestBuilder } from './product/index.js';
+// @ts-ignore
+import { PublisherRequestBuilderRequestsMetadata, type PublisherRequestBuilder } from './publisher/index.js';
+// @ts-ignore
+import { RegionRequestBuilderRequestsMetadata, type RegionRequestBuilder } from './region/index.js';
+// @ts-ignore
+import { ReservationRequestBuilderNavigationMetadata, ReservationRequestBuilderRequestsMetadata, type ReservationRequestBuilder } from './reservation/index.js';
+// @ts-ignore
+import { apiClientProxifier, ParseNodeFactoryRegistry, SerializationWriterFactoryRegistry, type BaseRequestBuilder, type KeysToExcludeForNavigationMetadata, type NavigationMetadata, type RequestAdapter } from '@microsoft/kiota-abstractions';
+// @ts-ignore
+import { FormParseNodeFactory, FormSerializationWriterFactory } from '@microsoft/kiota-serialization-form';
+// @ts-ignore
+import { JsonParseNodeFactory, JsonSerializationWriterFactory } from '@microsoft/kiota-serialization-json';
+// @ts-ignore
+import { MultipartSerializationWriterFactory } from '@microsoft/kiota-serialization-multipart';
+// @ts-ignore
+import { TextParseNodeFactory, TextSerializationWriterFactory } from '@microsoft/kiota-serialization-text';
+
+/**
+ * The main entry point of the SDK, exposes the configuration and the fluent API.
+ */
+export interface Client extends BaseRequestBuilder<Client> {
+    /**
+     * The Order property
+     */
+    get order(): OrderRequestBuilder;
+    /**
+     * The Partner property
+     */
+    get partner(): PartnerRequestBuilder;
+    /**
+     * The PriceList property
+     */
+    get priceList(): PriceListRequestBuilder;
+    /**
+     * The Product property
+     */
+    get product(): ProductRequestBuilder;
+    /**
+     * The Publisher property
+     */
+    get publisher(): PublisherRequestBuilder;
+    /**
+     * The Region property
+     */
+    get region(): RegionRequestBuilder;
+    /**
+     * The Reservation property
+     */
+    get reservation(): ReservationRequestBuilder;
+}
+/**
+ * Instantiates a new {@link Client} and sets the default values.
+ * @param requestAdapter The request adapter to use to execute the requests.
+ */
+// @ts-ignore
+export function createClient(requestAdapter: RequestAdapter) {
+    if (requestAdapter === undefined) {
+        throw new Error("requestAdapter cannot be undefined");
+    }
+    const serializationWriterFactory = requestAdapter.getSerializationWriterFactory() as SerializationWriterFactoryRegistry;
+    const parseNodeFactoryRegistry = requestAdapter.getParseNodeFactory() as ParseNodeFactoryRegistry;
+    const backingStoreFactory = requestAdapter.getBackingStoreFactory();
+    
+    if (parseNodeFactoryRegistry.registerDefaultDeserializer) {
+        parseNodeFactoryRegistry.registerDefaultDeserializer(JsonParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(TextParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(FormParseNodeFactory, backingStoreFactory);
+    }
+    
+    if (serializationWriterFactory.registerDefaultSerializer) {
+        serializationWriterFactory.registerDefaultSerializer(JsonSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(TextSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(FormSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(MultipartSerializationWriterFactory);
+    }
+    
+    if (requestAdapter.baseUrl === undefined || requestAdapter.baseUrl === null || requestAdapter.baseUrl === "") {
+        requestAdapter.baseUrl = "http://api.test.missioncontrol.io/partnerApi/v2";
+    }
+    const pathParameters: Record<string, unknown> = {
+        "baseurl": requestAdapter.baseUrl,
+    };
+    return apiClientProxifier<Client>(requestAdapter, pathParameters, ClientNavigationMetadata, undefined);
+}
+/**
+ * Uri template for the request builder.
+ */
+export const ClientUriTemplate = "{+baseurl}";
+/**
+ * Metadata for all the navigation properties in the request builder.
+ */
+export const ClientNavigationMetadata: Record<Exclude<keyof Client, KeysToExcludeForNavigationMetadata>, NavigationMetadata> = {
+    order: {
+        requestsMetadata: OrderRequestBuilderRequestsMetadata,
+        navigationMetadata: OrderRequestBuilderNavigationMetadata,
+    },
+    partner: {
+        requestsMetadata: PartnerRequestBuilderRequestsMetadata,
+    },
+    priceList: {
+        requestsMetadata: PriceListRequestBuilderRequestsMetadata,
+    },
+    product: {
+        requestsMetadata: ProductRequestBuilderRequestsMetadata,
+        navigationMetadata: ProductRequestBuilderNavigationMetadata,
+    },
+    publisher: {
+        requestsMetadata: PublisherRequestBuilderRequestsMetadata,
+    },
+    region: {
+        requestsMetadata: RegionRequestBuilderRequestsMetadata,
+    },
+    reservation: {
+        requestsMetadata: ReservationRequestBuilderRequestsMetadata,
+        navigationMetadata: ReservationRequestBuilderNavigationMetadata,
+    },
+};
+/* tslint:enable */
+/* eslint-enable */