@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.10

package/src/rlc-common/static/pollingContent.ts

@@ -1,225 +0,0 @@
-// 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
-    }
-  };
-}
-`;

package/src/rlc-common/test/buildRecordedClient.ts

@@ -1,18 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: to fix the handlebars issue
-import hbs from "handlebars";
-import { RLCModel } from "../interfaces.js";
-import { recordedClientContent } from "./template.js";
-
-export function buildRecordedClientFile(model: RLCModel) {
-  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",
-    }),
-  };
-}

package/src/rlc-common/test/buildSampleTest.ts

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

package/src/rlc-common/test/buildSnippets.ts

@@ -1,29 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: to fix the handlebars issue
-import hbs from "handlebars";
-import { getClientName } from "../helpers/nameConstructors.js";
-import { RLCModel } from "../interfaces.js";
-import { snippetsContent } from "./template.js";
-
-export function buildSnippets(model: RLCModel, clientName?: string, azureSdkForJs?: boolean) {
-  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;
-}

package/src/rlc-common/transformSampleGroups.ts

@@ -1,407 +0,0 @@
-import { getClientName } from "./helpers/nameConstructors.js";
-import { NameType, camelCase, normalizeName } from "./helpers/nameUtils.js";
-import { isAzurePackage } from "./helpers/packageUtil.js";
-import { buildSchemaObjectMap } from "./helpers/schemaHelpers.js";
-import { generateParameterTypeValue } from "./helpers/valueGenerationUtil.js";
-import {
-  OperationMethod,
-  OperationParameter,
-  PathMetadata,
-  Paths,
-  RLCModel,
-  RLCSampleDetail,
-  RLCSampleGroup,
-  SampleParameter,
-  SampleParameters,
-  Schema,
-} 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 function transformSampleGroups(model: RLCModel, allowMockValue = true) {
-  if (model.options?.multiClient || model.options?.isModularLibrary) {
-    // Not support to generate if multiple clients
-    // Not support to generate if modular libraries
-    return;
-  }
-  if ((model.sampleGroups && model.sampleGroups.length > 0) || !allowMockValue) {
-    // Skip to transform if already has sample data
-    // Skip to transform if not allow to mock value
-    return;
-  }
-  const rlcSampleGroups: RLCSampleGroup[] = [];
-  // Get all paths
-  const paths: Paths = model.paths;
-  const clientName = getClientName(model);
-  const clientInterfaceName = clientName.endsWith("Client")
-    ? `${clientName}`
-    : `${clientName}Client`;
-  const defaultFactoryName = normalizeName(
-    camelCase(`create ${clientInterfaceName}`),
-    NameType.Method,
-  );
-  const packageName = model.options?.packageDetails?.name ?? "";
-  const methodParameterMap = buildMethodParamMap(model);
-  const schemaObjectMap = buildSchemaObjectMap(model);
-  for (const path in paths) {
-    const pathDetails = paths[path];
-    if (!pathDetails) {
-      continue;
-    }
-    const methods = pathDetails.methods;
-    for (const method in methods) {
-      const importedDict: Record<string, Set<string>> = {};
-      const methodArray = methods[method];
-      if (!methodArray || methodArray.length === 0) {
-        continue;
-      }
-      const detail = methodArray[0];
-      if (!detail) {
-        continue;
-      }
-      const operatonConcante = getOperationConcate(
-        detail.operationName,
-        pathDetails.operationGroupName,
-        model.options?.sourceFrom,
-      );
-      const operationPrefix = normalizeName(
-        camelCase(transformSpecialLetterToSpace(operatonConcante)),
-        NameType.Operation,
-      );
-      const sampleGroup: RLCSampleGroup = {
-        filename: `${operationPrefix}Sample`,
-        defaultFactoryName,
-        clientPackageName: packageName,
-        samples: [],
-      };
-
-      // initialize the sample
-      const sample: RLCSampleDetail = {
-        description: `call operation ${detail.operationName}`,
-        name: `${operationPrefix}Sample`,
-        path,
-        defaultFactoryName,
-        clientParamAssignments: [],
-        pathParamAssignments: [],
-        methodParamAssignments: [],
-        clientParamNames: "",
-        pathParamNames: "",
-        methodParamNames: "",
-        method,
-        isLRO: detail.operationHelperDetail?.lroDetails?.isLongRunning ?? false,
-        isPaging: detail.operationHelperDetail?.isPaging ?? false,
-        useLegacyLro: false,
-      };
-      // client-level, path-level and method-level parameter preparation
-      const parameters: SampleParameters = {
-        client: convertClientLevelParameters(model, importedDict, schemaObjectMap),
-        path: convertPathLevelParameters(pathDetails, path, schemaObjectMap),
-        method: convertMethodLevelParameters(
-          methodArray,
-          schemaObjectMap,
-          methodParameterMap.get(operatonConcante),
-        ),
-      };
-      // enrich parameter details
-      enrichParameterInSample(sample, parameters);
-      // enrich LRO and pagination info
-      enrichLROAndPagingInSample(detail, importedDict, packageName);
-      sampleGroup.samples.push(sample);
-      rlcSampleGroups.push(sampleGroup);
-      enrichImportedString(sampleGroup, importedDict, defaultFactoryName, packageName);
-    }
-  }
-  return rlcSampleGroups;
-}
-
-function enrichLROAndPagingInSample(
-  operation: OperationMethod,
-  importedDict: Record<string, Set<string>>,
-  packageName: string,
-) {
-  const isLRO = operation.operationHelperDetail?.lroDetails?.isLongRunning ?? false,
-    isPaging = operation.operationHelperDetail?.isPaging ?? false;
-  if (isPaging) {
-    if (isLRO) {
-      // TODO: report warning this is not supported
-    }
-    addValueInImportedDict(packageName, "paginate", importedDict);
-  } else if (isLRO) {
-    addValueInImportedDict(packageName, "getLongRunningPoller", importedDict);
-  }
-}
-
-function transformSpecialLetterToSpace(str: string) {
-  if (!str) {
-    return str;
-  }
-  return str
-    .replace(/_/g, " ")
-    .replace(/\//g, " Or ")
-    .replace(/,|\.|\(|\)/g, " ")
-    .replace("'s ", " ");
-}
-
-function enrichImportedString(
-  sampleGroup: RLCSampleGroup,
-  importedDict: Record<string, Set<string>>,
-  defaultFactoryName: string,
-  packageName: string,
-) {
-  const importedTypes: string[] = [];
-  if (!importedDict[packageName] || importedDict[packageName].size === 0) {
-    importedTypes.push(`import ${defaultFactoryName} from "${packageName}";`);
-  }
-  for (const key in importedDict) {
-    const importedSet = importedDict[key];
-    if (!importedSet) {
-      continue;
-    }
-    const values = Array.from(importedSet).join(", ");
-    const hasDefaultFactory = key === packageName ? `${defaultFactoryName},` : "";
-    importedTypes.push(`import ${hasDefaultFactory} { ${values} } from "${key}";`);
-  }
-  sampleGroup.importedTypes = importedTypes;
-}
-
-function enrichParameterInSample(sample: RLCSampleDetail, parameters: SampleParameters) {
-  sample.clientParamAssignments = getAssignmentStrArray(parameters.client);
-  sample.clientParamNames = getContactParameterNames(parameters.client);
-  sample.pathParamAssignments = getAssignmentStrArray(parameters.path);
-  sample.pathParamNames = getContactParameterNames(parameters.path);
-  // Directly apply the inline option value as method parameter
-  sample.methodParamNames = parameters.method.length > 0 ? (parameters.method[0]?.value ?? "") : "";
-}
-
-function getAssignmentStrArray(parameters: SampleParameter[]) {
-  return parameters.filter((p) => !!p.assignment).map((p) => p.assignment!);
-}
-
-function getContactParameterNames(parameters: SampleParameter[]) {
-  return parameters
-    .filter((p) => p.name != null)
-    .map((p) => p.name!)
-    .join(",");
-}
-
-function convertClientLevelParameters(
-  model: RLCModel,
-  importedDict: Record<string, Set<string>>,
-  schemaMap: Map<string, Schema>,
-): SampleParameter[] {
-  if (!model.options) {
-    return [];
-  }
-  const clientParams: SampleParameter[] = [];
-  const urlParameters = model?.urlInfo?.urlParameters?.filter(
-    // Do not include parameters with constant values in the signature, these should go in the options bag
-    (p) => p.value === undefined,
-  );
-  const {
-    addCredentials,
-    credentialScopes,
-    credentialKeyHeaderName,
-    customHttpAuthHeaderName,
-    flavor,
-  } = model.options;
-  const hasUrlParameter = !!urlParameters,
-    hasCredentials =
-      addCredentials && (credentialScopes || credentialKeyHeaderName || customHttpAuthHeaderName);
-
-  if (hasUrlParameter) {
-    // convert the host parameters in url
-    const clientParamAssignments = urlParameters.map((urlParameter) => {
-      const urlValue = generateParameterTypeValue(urlParameter.type, urlParameter.name, schemaMap);
-      const normalizedName = normalizeName(urlParameter.name, NameType.Parameter);
-      return {
-        name: normalizedName,
-        assignment: `const ${normalizedName} = ` + urlValue + `;`,
-      };
-    });
-
-    clientParams.push(...clientParamAssignments);
-  }
-  if (hasCredentials) {
-    // Currently only support token credential
-    const apiKeyCredentialPackage = isAzurePackage(model)
-      ? "@azure/core-auth"
-      : "@typespec/ts-http-runtime";
-    const tokenCredentialPackage = isAzurePackage(model)
-      ? "@azure/identity"
-      : "@typespec/ts-http-runtime";
-    if (credentialKeyHeaderName && isAzurePackage(model)) {
-      clientParams.push({
-        name: "credential",
-        assignment: `const credential = new AzureKeyCredential("{Your API key}");`,
-      });
-      addValueInImportedDict(apiKeyCredentialPackage, "AzureKeyCredential", importedDict);
-    } else if ((credentialKeyHeaderName && flavor !== "azure") || customHttpAuthHeaderName) {
-      clientParams.push({
-        name: "credential",
-        assignment: `const credential = { key: "{Your API key}"};`,
-      });
-    } else if (isAzurePackage(model)) {
-      clientParams.push({
-        name: "credential",
-        assignment: "const credential = new DefaultAzureCredential();",
-      });
-      addValueInImportedDict(tokenCredentialPackage, "DefaultAzureCredential", importedDict);
-    } else {
-      clientParams.push({
-        name: "credential",
-        assignment: `const credential = {getToken: () => Promise.resolve({ token: "{Your token}", expiresOnTimestamp: 0 })};`,
-      });
-    }
-  }
-  return clientParams;
-}
-
-function convertPathLevelParameters(
-  pathDetail: PathMetadata,
-  path: string,
-  schemaMap: Map<string, Schema>,
-): SampleParameter[] {
-  const pathItself = {
-    name: `"${path}"`,
-  };
-  const pathParams = (pathDetail || []).pathParameters.map((p) => {
-    const pathParam: SampleParameter = {
-      name: normalizeName(p.name, NameType.Parameter),
-    };
-    const value = generateParameterTypeValue(p.type, p.name, schemaMap);
-    pathParam.assignment = `const ${pathParam.name} =` + value + `;`;
-    return pathParam;
-  });
-  return [pathItself].concat(pathParams);
-}
-
-function convertMethodLevelParameters(
-  methods: OperationMethod[],
-  schemaMap: Map<string, Schema>,
-  operationParameter?: OperationParameter,
-): SampleParameter[] {
-  if (
-    !methods ||
-    methods.length === 0 ||
-    !operationParameter ||
-    operationParameter.parameters.length === 0
-  ) {
-    return [];
-  }
-  const rawMethodParams = operationParameter.parameters;
-  const method = methods[0];
-  const requestParameter = rawMethodParams[0];
-  if (!method || !requestParameter) {
-    return [];
-  }
-  const hasInputParams = !!rawMethodParams && rawMethodParams.length > 0,
-    requireParam = !method.hasOptionalOptions;
-  if (!hasInputParams && !requireParam) {
-    return [];
-  }
-
-  const allSideAssignments = [],
-    querySideAssignments: string[] = [],
-    headerSideAssignments: string[] = [];
-  if (
-    !!requestParameter.body &&
-    requestParameter.body &&
-    requestParameter.body.body &&
-    requestParameter.body.body?.length > 0
-  ) {
-    const body = requestParameter.body.body[0];
-    if (body) {
-      const bodyTypeName = body.typeName ?? body.type;
-      if (bodyTypeName !== "string" && body.oriSchema) {
-        schemaMap.set(bodyTypeName, body.oriSchema);
-      }
-      allSideAssignments.push(
-        ` body: ` + generateParameterTypeValue(bodyTypeName, "body", schemaMap),
-      );
-    }
-  }
-
-  requestParameter.parameters
-    ?.filter((p) => p.type === "query")
-    .forEach((p) => {
-      const name = `${p.name}`;
-      querySideAssignments.push(
-        `${name}: ` + generateParameterTypeValue(p.param.type, name, schemaMap),
-      );
-    });
-
-  if (querySideAssignments.length > 0) {
-    allSideAssignments.push(` queryParameters: { ` + querySideAssignments.join(", ") + `}`);
-  }
-  requestParameter.parameters
-    ?.filter((p) => p.type === "header")
-    .filter((p) => p.name.toLowerCase() !== "contenttype")
-    .forEach((p) => {
-      const name = `${p.name}`;
-      headerSideAssignments.push(
-        `${name}: ` + generateParameterTypeValue(p.param.type, name, schemaMap),
-      );
-    });
-  if (headerSideAssignments.length > 0) {
-    allSideAssignments.push(` headers: { ` + headerSideAssignments.join(", ") + `}`);
-  }
-  const contentType = requestParameter.parameters
-    ?.filter((p) => p.type === "header")
-    .filter((p) => p.name.toLowerCase() === "contenttype");
-  const firstContentType = contentType?.[0];
-  if (firstContentType) {
-    allSideAssignments.push(
-      ` ${firstContentType.name}: ` +
-        generateParameterTypeValue(firstContentType.param.type, firstContentType.name, schemaMap),
-    );
-  }
-  let value: string = `{}`;
-  if (allSideAssignments.length > 0) {
-    value = `{ ` + allSideAssignments.join(", ") + `}`;
-  } else {
-    return [];
-  }
-
-  const optionParam: SampleParameter = {
-    name: "options",
-    assignment: `const options =` + value + `;`,
-    value,
-  };
-  return [optionParam];
-}
-
-function addValueInImportedDict(
-  key: string,
-  val: string,
-  importedDict: Record<string, Set<string>>,
-) {
-  if (!importedDict[key]) {
-    importedDict[key] = new Set<string>();
-  }
-  importedDict[key].add(val);
-}
-
-function buildMethodParamMap(model: RLCModel): Map<string, OperationParameter> {
-  const map = new Map<string, OperationParameter>();
-  (model.parameters ?? []).forEach((p) => {
-    const operatonConcante = getOperationConcate(
-      p.operationName,
-      p.operationGroup,
-      model.options?.sourceFrom,
-    );
-    map.set(operatonConcante, p);
-  });
-  return map;
-}
-
-function getOperationConcate(opName: string, opGroup: string, sourceFrom?: string) {
-  return sourceFrom === "Swagger"
-    ? opGroup === "" || opGroup === "Client"
-      ? opName
-      : `${opGroup}${opName}`
-    : `${opGroup}_${opName}`;
-}