@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/dist/src/rlc-common/static/polling-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polling-content.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/static/polling-content.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,ygPA6N1B,CAAC"}

package/dist/src/rlc-common/static/polling-content.js

@@ -0,0 +1,225 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export const pollingContent = `
+import type { Client, HttpResponse } from "@azure-rest/core-client";
+import type { AbortSignalLike } from "@azure/abort-controller";
+import type {
+  CancelOnProgress,
+  CreateHttpPollerOptions,
+  RunningOperation,
+  OperationResponse,
+  OperationState,
+} from "@azure/core-lro";
+ import { createHttpPoller } from "@azure/core-lro";
+{{#if clientOverload}}
+import type {
+  {{#each importedResponses}}
+  {{this}},
+  {{/each}}
+} from "./responses{{#if isEsm}}.js{{/if}}";
+{{/if}}
+
+/**
+ * A simple poller that can be used to poll a long running operation.
+ */
+export interface SimplePollerLike<
+  TState extends OperationState<TResult>,
+  TResult
+> {
+  /**
+   * Returns true if the poller has finished polling.
+   */
+  isDone(): boolean;
+  /**
+   * Returns the state of the operation.
+   */
+  getOperationState(): TState;
+  /**
+   * Returns the result value of the operation,
+   * regardless of the state of the poller.
+   * It can return undefined or an incomplete form of the final TResult value
+   * depending on the implementation.
+   */
+  getResult(): TResult | undefined;
+  /**
+   * Returns a promise that will resolve once a single polling request finishes.
+   * It does this by calling the update method of the Poller's operation.
+   */
+  poll(options?: { abortSignal?: AbortSignalLike }): Promise<TState>;
+  /**
+   * Returns a promise that will resolve once the underlying operation is completed.
+   */
+  pollUntilDone(pollOptions?: {
+    abortSignal?: AbortSignalLike;
+  }): Promise<TResult>;
+  /**
+   * Invokes the provided callback after each polling is completed,
+   * sending the current state of the poller's operation.
+   *
+   * It returns a method that can be used to stop receiving updates on the given callback function.
+   */
+  onProgress(callback: (state: TState) => void): CancelOnProgress;
+
+  /**
+   * Returns a promise that could be used for serialized version of the poller's operation
+   * by invoking the operation's serialize method.
+   */
+  serialize(): Promise<string>;
+
+  /**
+   * Wait the poller to be submitted.
+   */
+  submitted(): Promise<void>;
+
+  /**
+   * Returns a string representation of the poller's operation. Similar to serialize but returns a string.
+   * @deprecated Use serialize() instead.
+   */
+  toString(): string;
+
+  /**
+   * Stops the poller from continuing to poll. Please note this will only stop the client-side polling
+   * @deprecated Use abortSignal to stop polling instead.
+   */
+  stopPolling(): void;
+
+  /**
+   * Returns true if the poller is stopped.
+   * @deprecated Use abortSignal status to track this instead.
+   */
+  isStopped(): boolean;
+}
+
+/**
+ * Helper function that builds a Poller object to help polling a long running operation.
+ * @param client - Client to use for sending the request to get additional pages.
+ * @param initialResponse - The initial response.
+ * @param options - Options to set a resume state or custom polling interval.
+ * @returns - A poller object to poll for operation state updates and eventually get the final response.
+ */
+{{#if clientOverload}}
+{{#each overloadMap}}
+export async function getLongRunningPoller<
+  TResult extends {{ this.finalResponses }}
+>(
+  client: Client,
+  initialResponse: {{ this.initialResponses }},
+  options?: CreateHttpPollerOptions<TResult, OperationState<TResult>>
+): Promise<SimplePollerLike<OperationState<TResult>, TResult>>;
+{{/each}}
+{{/if}}
+export async function getLongRunningPoller<TResult extends HttpResponse>(
+    client: Client,
+    initialResponse: TResult,
+    options: CreateHttpPollerOptions<TResult, OperationState<TResult>> = {}
+    ): Promise<SimplePollerLike<OperationState<TResult>, TResult>> { 
+  const abortController = new AbortController();
+  const poller: RunningOperation<TResult> = {
+    sendInitialRequest: async () => {
+      // In the case of Rest Clients we are building the LRO poller object from a response that's the reason
+      // we are not triggering the initial request here, just extracting the information from the
+      // response we were provided.
+      return getLroResponse(initialResponse);
+    },
+    sendPollRequest: async (
+      path: string,
+      pollOptions?: { abortSignal?: AbortSignalLike }
+    ) => {
+      // This is the callback that is going to be called to poll the service
+      // to get the latest status. We use the client provided and the polling path
+      // which is an opaque URL provided by caller, the service sends this in one of the following headers: operation-location, azure-asyncoperation or location
+      // depending on the lro pattern that the service implements. If non is provided we default to the initial path.
+      function abortListener(): void {
+        abortController.abort();
+      }
+      const inputAbortSignal = pollOptions?.abortSignal;
+      const abortSignal = abortController.signal;
+      if (inputAbortSignal?.aborted) {
+        abortController.abort();
+      } else if (!abortSignal.aborted) {
+        inputAbortSignal?.addEventListener("abort", abortListener, {
+          once: true
+        });
+      }
+      let response;
+      try {
+        response = await client
+          .pathUnchecked(path ?? initialResponse.request.url)
+          .get({ abortSignal });
+      } finally {
+        inputAbortSignal?.removeEventListener("abort", abortListener);
+      }
+      const lroResponse = getLroResponse(response as TResult);
+      lroResponse.rawResponse.headers["x-ms-original-url"] =
+        initialResponse.request.url;
+      return lroResponse;
+    }
+  };
+
+  options.resolveOnUnsuccessful = options.resolveOnUnsuccessful ?? true;
+  const httpPoller = createHttpPoller(poller, options);
+  const simplePoller: SimplePollerLike<OperationState<TResult>, TResult> = {
+    isDone() {
+      return httpPoller.isDone;
+    },
+    isStopped() {
+      return abortController.signal.aborted;
+    },
+    getOperationState() {
+      if (!httpPoller.operationState) {
+        throw new Error(
+          "Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState()."
+        );
+      }
+      return httpPoller.operationState;
+    },
+    getResult() {
+      return httpPoller.result;
+    },
+    toString() {
+      if (!httpPoller.operationState) {
+        throw new Error(
+          "Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState()."
+        );
+      }
+      return JSON.stringify({
+        state: httpPoller.operationState
+      });
+    },
+    stopPolling() {
+      abortController.abort();
+    },
+    onProgress: httpPoller.onProgress,
+    poll: httpPoller.poll,
+    pollUntilDone: httpPoller.pollUntilDone,
+    serialize: httpPoller.serialize,
+    submitted: httpPoller.submitted
+  };
+  return simplePoller;
+}
+
+/**
+ * Converts a Rest Client response to a response that the LRO implementation understands
+ * @param response - a rest client http response
+ * @returns - An LRO response that the LRO implementation understands
+ */
+function getLroResponse<TResult extends HttpResponse>(
+  response: TResult
+): OperationResponse<TResult>  {
+  if (Number.isNaN(response.status)) {
+    throw new TypeError(
+      \`Status code of the response is not a number. Value: \${response.status}\`
+    );
+  }
+
+  return {
+    flatResponse: response,
+    rawResponse: {
+      ...response,
+      statusCode: Number.parseInt(response.status),
+      body: response.body
+    }
+  };
+}
+`;
+//# sourceMappingURL=polling-content.js.map

package/dist/src/rlc-common/static/polling-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polling-content.js","sourceRoot":"","sources":["../../../../src/rlc-common/static/polling-content.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6N7B,CAAC"}

package/dist/src/rlc-common/static/sample-template.d.ts

@@ -0,0 +1,2 @@
+export declare const sampleTemplate = "\n{{#each importedTypes}}\n{{this}}\n{{/each}}\nimport \"dotenv/config\";\n\n{{#each samples}}\n/**\n * This sample demonstrates how to {{this.description}}\n *\n * @summary {{this.description}}\n {{#if this.originalFileLocation}}\n * x-ms-original-file: {{this.originalFileLocation}}\n {{/if}}\n */\nasync function {{name}}(): Promise<void>  {\n  {{#each this.clientParamAssignments}}\n  {{this}}\n  {{/each}}\n  const client = {{this.defaultFactoryName}}({{this.clientParamNames}});\n  {{#each this.pathParamAssignments}}\n  {{this}}\n  {{/each}}\n  {{#each this.methodParamAssignments}}\n  {{this}}\n  {{/each}}\n  {{#if this.isPaging}}\n  const initialResponse = await client.path({{this.pathParamNames}}).{{method}}({{methodParamNames}});\n  const pageData = paginate(client, initialResponse);\n  const result = [];\n  for await (const item of pageData) {\n    result.push(item);\n  }\n  {{else if this.isLRO}}\n  const initialResponse ={{#unless this.useLegacyLro}} await{{/unless}} client.path({{this.pathParamNames}}).{{method}}({{methodParamNames}});\n  const poller = await getLongRunningPoller(client, initialResponse);\n  const result = await poller.pollUntilDone();\n  {{else}}\n  const result = await client.path({{this.pathParamNames}}).{{method}}({{methodParamNames}});\n  {{/if}}\n  console.log(result);\n}\n\n{{/each}}\n\nasync function main(): Promise<void> {\n{{#each samples}}\n  await {{this.name}}();\n{{/each}}\n}\n\nmain().catch(console.error);\n";
+//# sourceMappingURL=sample-template.d.ts.map

package/dist/src/rlc-common/static/sample-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-template.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/static/sample-template.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,o8CAoD1B,CAAC"}

package/dist/src/rlc-common/static/sample-template.js

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export const sampleTemplate = `
+{{#each importedTypes}}
+{{this}}
+{{/each}}
+import "dotenv/config";
+
+{{#each samples}}
+/**
+ * This sample demonstrates how to {{this.description}}
+ *
+ * @summary {{this.description}}
+ {{#if this.originalFileLocation}}
+ * x-ms-original-file: {{this.originalFileLocation}}
+ {{/if}}
+ */
+async function {{name}}(): Promise<void>  {
+  {{#each this.clientParamAssignments}}
+  {{this}}
+  {{/each}}
+  const client = {{this.defaultFactoryName}}({{this.clientParamNames}});
+  {{#each this.pathParamAssignments}}
+  {{this}}
+  {{/each}}
+  {{#each this.methodParamAssignments}}
+  {{this}}
+  {{/each}}
+  {{#if this.isPaging}}
+  const initialResponse = await client.path({{this.pathParamNames}}).{{method}}({{methodParamNames}});
+  const pageData = paginate(client, initialResponse);
+  const result = [];
+  for await (const item of pageData) {
+    result.push(item);
+  }
+  {{else if this.isLRO}}
+  const initialResponse ={{#unless this.useLegacyLro}} await{{/unless}} client.path({{this.pathParamNames}}).{{method}}({{methodParamNames}});
+  const poller = await getLongRunningPoller(client, initialResponse);
+  const result = await poller.pollUntilDone();
+  {{else}}
+  const result = await client.path({{this.pathParamNames}}).{{method}}({{methodParamNames}});
+  {{/if}}
+  console.log(result);
+}
+
+{{/each}}
+
+async function main(): Promise<void> {
+{{#each samples}}
+  await {{this.name}}();
+{{/each}}
+}
+
+main().catch(console.error);
+`;
+//# sourceMappingURL=sample-template.js.map

package/dist/src/rlc-common/static/sample-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-template.js","sourceRoot":"","sources":["../../../../src/rlc-common/static/sample-template.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoD7B,CAAC"}

package/dist/src/rlc-common/static/serialize-helper.d.ts

@@ -0,0 +1,6 @@
+export declare const buildMultiCollectionContent = "\nexport function buildMultiCollection(\n  items: string[],\n  parameterName: string\n): string {\n  return items\n    .map((item, index) => {\n      if (index === 0) {\n        return item;\n      }\n      return `${parameterName}=${item}`;\n    })\n    .join(\"&\");\n}";
+export declare const buildPipeCollectionContent = "\nexport function buildPipeCollection(items: string[] | number[]): string {\n  return items.join(\"|\");\n}";
+export declare const buildSsvCollectionContent = "\nexport function buildSsvCollection(items: string[] | number[]): string {\n  return items.join(\" \");\n}";
+export declare const buildTsvCollectionContent = "\nexport function buildTsvCollection(items: string[] | number[]): string {\n  return items.join(\"\\t\");\n}";
+export declare const buildCsvCollectionContent = "\nexport function buildCsvCollection(items: string[] | number[]): string {\n  return items.join(\",\");\n}";
+//# sourceMappingURL=serialize-helper.d.ts.map

package/dist/src/rlc-common/static/serialize-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-helper.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/static/serialize-helper.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,oRAatC,CAAC;AAEH,eAAO,MAAM,0BAA0B,gHAGrC,CAAC;AAEH,eAAO,MAAM,yBAAyB,+GAGpC,CAAC;AAEH,eAAO,MAAM,yBAAyB,iHAGpC,CAAC;AAEH,eAAO,MAAM,yBAAyB,+GAGpC,CAAC"}

package/dist/src/rlc-common/static/serialize-helper.js

@@ -0,0 +1,31 @@
+export const buildMultiCollectionContent = `
+export function buildMultiCollection(
+  items: string[],
+  parameterName: string
+): string {
+  return items
+    .map((item, index) => {
+      if (index === 0) {
+        return item;
+      }
+      return \`\${parameterName}=\${item}\`;
+    })
+    .join("&");
+}`;
+export const buildPipeCollectionContent = `
+export function buildPipeCollection(items: string[] | number[]): string {
+  return items.join("|");
+}`;
+export const buildSsvCollectionContent = `
+export function buildSsvCollection(items: string[] | number[]): string {
+  return items.join(" ");
+}`;
+export const buildTsvCollectionContent = `
+export function buildTsvCollection(items: string[] | number[]): string {
+  return items.join("\\t");
+}`;
+export const buildCsvCollectionContent = `
+export function buildCsvCollection(items: string[] | number[]): string {
+  return items.join(",");
+}`;
+//# sourceMappingURL=serialize-helper.js.map

package/dist/src/rlc-common/static/serialize-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-helper.js","sourceRoot":"","sources":["../../../../src/rlc-common/static/serialize-helper.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;EAazC,CAAC;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;EAGxC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG;;;EAGvC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG;;;EAGvC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG;;;EAGvC,CAAC"}

package/dist/src/rlc-common/test/build-karma-config.d.ts

@@ -0,0 +1,6 @@
+import { RLCModel } from "../interfaces.js";
+export declare function buildKarmaConfigFile(_model: RLCModel): {
+    path: string;
+    content: string;
+};
+//# sourceMappingURL=build-karma-config.d.ts.map

package/dist/src/rlc-common/test/build-karma-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-karma-config.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-karma-config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,QAAQ;;;EAKpD"}

package/dist/src/rlc-common/test/build-karma-config.js

@@ -0,0 +1,11 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: to fix the handlebars issue
+import hbs from "handlebars";
+import { karmaConfig } from "./template.js";
+export function buildKarmaConfigFile(_model) {
+    return {
+        path: "karma.conf.js",
+        content: hbs.compile(karmaConfig, { noEscape: true })({}),
+    };
+}
+//# sourceMappingURL=build-karma-config.js.map

package/dist/src/rlc-common/test/build-karma-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-karma-config.js","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-karma-config.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,0CAA0C;AAC1C,OAAO,GAAG,MAAM,YAAY,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,MAAM,UAAU,oBAAoB,CAAC,MAAgB;IACnD,OAAO;QACL,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;KAC1D,CAAC;AACJ,CAAC"}

package/dist/src/rlc-common/test/build-recorded-client.d.ts

@@ -0,0 +1,6 @@
+import { RLCModel } from "../interfaces.js";
+export declare function buildRecordedClientFile(model: RLCModel): {
+    path: string;
+    content: string;
+};
+//# sourceMappingURL=build-recorded-client.d.ts.map

package/dist/src/rlc-common/test/build-recorded-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-recorded-client.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-recorded-client.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ;;;EAWtD"}

package/dist/src/rlc-common/test/build-recorded-client.js

@@ -0,0 +1,17 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: to fix the handlebars issue
+import hbs from "handlebars";
+import { recordedClientContent } from "./template.js";
+export function buildRecordedClientFile(model) {
+    const recordedClientFileContents = hbs.compile(recordedClientContent, {
+        noEscape: true,
+    });
+    return {
+        path: "test/public/utils/recordedClient.ts",
+        content: recordedClientFileContents({
+            isEsm: model.options?.moduleKind === "esm",
+            isCjs: model.options?.moduleKind === "cjs",
+        }),
+    };
+}
+//# sourceMappingURL=build-recorded-client.js.map

package/dist/src/rlc-common/test/build-recorded-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-recorded-client.js","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-recorded-client.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,0CAA0C;AAC1C,OAAO,GAAG,MAAM,YAAY,CAAC;AAE7B,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAEtD,MAAM,UAAU,uBAAuB,CAAC,KAAe;IACrD,MAAM,0BAA0B,GAAG,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE;QACpE,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IACH,OAAO;QACL,IAAI,EAAE,qCAAqC;QAC3C,OAAO,EAAE,0BAA0B,CAAC;YAClC,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,UAAU,KAAK,KAAK;YAC1C,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,UAAU,KAAK,KAAK;SAC3C,CAAC;KACH,CAAC;AACJ,CAAC"}

package/dist/src/rlc-common/test/build-sample-test.d.ts

@@ -0,0 +1,6 @@
+import { RLCModel } from "../interfaces.js";
+export declare function buildSampleTest(model: RLCModel): {
+    path: string;
+    content: string;
+};
+//# sourceMappingURL=build-sample-test.d.ts.map

package/dist/src/rlc-common/test/build-sample-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-sample-test.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-sample-test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ;;;EAQ9C"}

package/dist/src/rlc-common/test/build-sample-test.js

@@ -0,0 +1,14 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: to fix the handlebars issue
+import hbs from "handlebars";
+import { sampleTestContent } from "./template.js";
+export function buildSampleTest(model) {
+    return {
+        path: "test/public/sampleTest.spec.ts",
+        content: hbs.compile(sampleTestContent, { noEscape: true })({
+            isEsm: model.options?.moduleKind === "esm",
+            isCjs: model.options?.moduleKind === "cjs",
+        }),
+    };
+}
+//# sourceMappingURL=build-sample-test.js.map

package/dist/src/rlc-common/test/build-sample-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-sample-test.js","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-sample-test.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,0CAA0C;AAC1C,OAAO,GAAG,MAAM,YAAY,CAAC;AAE7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,MAAM,UAAU,eAAe,CAAC,KAAe;IAC7C,OAAO;QACL,IAAI,EAAE,gCAAgC;QACtC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,iBAAiB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;YAC1D,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,UAAU,KAAK,KAAK;YAC1C,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,UAAU,KAAK,KAAK;SAC3C,CAAC;KACH,CAAC;AACJ,CAAC"}

package/dist/src/rlc-common/test/build-snippets.d.ts

@@ -0,0 +1,6 @@
+import { RLCModel } from "../interfaces.js";
+export declare function buildSnippets(model: RLCModel, clientName?: string, azureSdkForJs?: boolean): {
+    path: string;
+    content: string;
+} | undefined;
+//# sourceMappingURL=build-snippets.d.ts.map

package/dist/src/rlc-common/test/build-snippets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-snippets.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-snippets.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO;;;cAqB1F"}

package/dist/src/rlc-common/test/build-snippets.js

@@ -0,0 +1,26 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: to fix the handlebars issue
+import hbs from "handlebars";
+import { getClientName } from "../helpers/name-constructors.js";
+import { snippetsContent } from "./template.js";
+export function buildSnippets(model, clientName, azureSdkForJs) {
+    const azureSdkForJsInfo = azureSdkForJs ? azureSdkForJs : model.options?.azureSdkForJs;
+    // to keep the same config for azure scope in buildReadmeFile.ts
+    if ((model?.options?.packageDetails?.scopeName === "azure" ||
+        model?.options?.packageDetails?.scopeName === "azure-rest") &&
+        model.options.addCredentials &&
+        azureSdkForJsInfo) {
+        return {
+            path: "test/snippets.spec.ts",
+            content: hbs.compile(snippetsContent, { noEscape: true })({
+                clientClassName: clientName ? clientName : getClientName(model),
+                azureArm: model.options?.azureArm,
+                azureSdkForJs: azureSdkForJsInfo,
+                isModularLibrary: model.options.isModularLibrary,
+                hasSubscriptionId: model.options.hasSubscriptionId,
+            }),
+        };
+    }
+    return undefined;
+}
+//# sourceMappingURL=build-snippets.js.map

package/dist/src/rlc-common/test/build-snippets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-snippets.js","sourceRoot":"","sources":["../../../../src/rlc-common/test/build-snippets.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,0CAA0C;AAC1C,OAAO,GAAG,MAAM,YAAY,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,UAAU,aAAa,CAAC,KAAe,EAAE,UAAmB,EAAE,aAAuB;IACzF,MAAM,iBAAiB,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,EAAE,aAAa,CAAC;IACvF,gEAAgE;IAChE,IACE,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,SAAS,KAAK,OAAO;QACpD,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,SAAS,KAAK,YAAY,CAAC;QAC7D,KAAK,CAAC,OAAO,CAAC,cAAc;QAC5B,iBAAiB,EACjB,CAAC;QACD,OAAO;YACL,IAAI,EAAE,uBAAuB;YAC7B,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;gBACxD,eAAe,EAAE,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC;gBAC/D,QAAQ,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ;gBACjC,aAAa,EAAE,iBAAiB;gBAChC,gBAAgB,EAAE,KAAK,CAAC,OAAO,CAAC,gBAAgB;gBAChD,iBAAiB,EAAE,KAAK,CAAC,OAAO,CAAC,iBAAiB;aACnD,CAAC;SACH,CAAC;IACJ,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/src/rlc-common/transform-sample-groups.d.ts

@@ -0,0 +1,9 @@
+import { RLCModel, RLCSampleGroup } from "./interfaces.js";
+/**
+ * Transform the sample data based RLC detail e.g path, operations & schemas
+ * @param model RLC detail
+ * @param allowMockValue allow to mock value if not exist, currently we always generate mock value
+ * @returns Generated sample data or undefined if not support to generate
+ */
+export declare function transformSampleGroups(model: RLCModel, allowMockValue?: boolean): RLCSampleGroup[] | undefined;
+//# sourceMappingURL=transform-sample-groups.d.ts.map

package/dist/src/rlc-common/transform-sample-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-sample-groups.d.ts","sourceRoot":"","sources":["../../../src/rlc-common/transform-sample-groups.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,QAAQ,EAER,cAAc,EAIf,MAAM,iBAAiB,CAAC;AAEzB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,cAAc,UAAO,gCA8F3E"}