diag | DiagnosticReport<{ add-parameter-duplicate: { default: CallableMessage<["paramName", "operationName"]>; }; api-version-not-string: { default: "Api version must be a string or a string enum"; }; api-version-undefined: { default: CallableMessage<["version"]>; }; auto-merge-service-conflict: { default: "Auto-merging service client must be empty."; }; client-location-conflict: { default: "@clientLocation with string target could not be used for multiple root clients scenario"; modelPropertyToClientInitialization: CallableMessage<["parameterName"]>; modelPropertyToString: "`@clientLocation` can only move model properties to interfaces or namespaces."; operationToOperation: "`@clientLocation` cannot be used to move an operation to another operation. Operations can only be moved to interfaces or namespaces."; }; client-location-wrong-type: { default: "`@clientLocation` could only move operation to the interface or namespace belong to the root namespace with `@service`."; }; client-name-ineffective: { default: CallableMessage<["name"]>; override: CallableMessage<["name", "originalMethodName"]>; }; client-option: { default: "@clientOption is experimental and should only be used for temporary workarounds. This usage must be suppressed."; }; client-option-requires-scope: { default: "@clientOption should be applied with a specific language scope since it is highly likely this is language-specific."; }; client-service: { default: CallableMessage<["name"]>; }; conflict-access-override: { default: "@access override conflicts with the access calculated from operation or other @access override."; }; conflicting-multipart-model-usage: { default: CallableMessage<["modelName", "modelName", "modelName"]>; }; discriminator-not-constant: { default: CallableMessage<["discriminator"]>; }; discriminator-not-string: { default: CallableMessage<["discriminator", "discriminatorValue"]>; }; duplicate-client-name: { default: CallableMessage<["name", "scope"]>; nonDecorator: CallableMessage<["name", "scope"]>; }; duplicate-client-name-warning: { default: CallableMessage<["name", "scope"]>; nonDecorator: CallableMessage<["name", "scope"]>; }; duplicate-decorator: { default: CallableMessage<["decoratorName"]>; }; duplicate-example-file: { default: CallableMessage<["filename", "title", "operationId"]>; }; empty-client-name: { default: "Cannot pass an empty value to the @clientName decorator"; }; empty-client-namespace: { default: "Cannot pass an empty value to the @clientNamespace decorator"; }; example-loading: { default: CallableMessage<["filename", "error"]>; noDirectory: CallableMessage<["directory"]>; noOperationId: CallableMessage<["filename"]>; }; example-value-no-mapping: { default: CallableMessage<["relativePath", "value"]>; }; external-library-version-mismatch: { default: CallableMessage<["libraryName", "versionA", "versionB"]>; }; external-type-on-model-property: { default: "@alternateType with external type information cannot be applied to model properties. Please apply it to the type definition itself (Scalar, Model, Enum, or Union) instead."; }; flatten-polymorphism: { default: "Cannot flatten property of polymorphic type."; }; inconsistent-multiple-service: { default: "All services must have the same server and auth definitions."; }; invalid-access: { default: “Access value must be “public” or “internal”.”; }; invalid-alternate-type: { default: CallableMessage<["kindName"]>; }; invalid-client-doc-mode: { default: CallableMessage<["mode"]>; }; invalid-client-service-multiple: { default: "`@client` with multiple services is only allowed on `Namespace`."; }; invalid-deserializeEmptyStringAsNull-target-type: { default: "@deserializeEmptyStringAsNull can only be applied to `ModelProperty` of type 'string' or a `Scalar` derived from 'string'."; }; invalid-encode-for-collection-format: { default: "Only encode of `ArrayEncoding.pipeDelimited` and `ArrayEncoding.spaceDelimited` is supported for collection format."; }; invalid-initialized-by: { default: CallableMessage<["message"]>; }; invalid-mark-as-lro-target: { default: CallableMessage<[]>; }; invalid-mark-as-pageable-target: { default: CallableMessage<[]>; }; invalid-usage: { default: "Usage value must be one of: 2 (input), 4 (output), 256 (json), or 512 (xml)."; }; legacy-hierarchy-building-circular-reference: { default: "@hierarchyBuilding decorator causes recursive base type reference."; }; legacy-hierarchy-building-conflict: { property-missing: CallableMessage<["childModel", "propertyName", "parentModel"]>; type-mismatch: CallableMessage<["propertyName", "childModel", "parentModel"]>; }; mark-as-lro-ineffective: { default: CallableMessage<[]>; }; mark-as-pageable-ineffective: { default: CallableMessage<[]>; }; missing-scope: { default: CallableMessage<["decoratorName"]>; }; missing-service-versions: { default: CallableMessage<["serviceName", "missingVersions"]>; }; multiple-param-alias: { default: CallableMessage<["originalName", "firstParamAlias"]>; }; multiple-response-types: { default: CallableMessage<["operation"]>; }; nested-client-service-not-subset: { default: "Nested client's services must be a subset of the parent client's services. If no service is needed, omit the `service` property to inherit from the parent."; }; no-corresponding-method-param: { default: CallableMessage<["paramName", "methodName"]>; }; no-emitter-name: { default: "Can not find name for your emitter, please check your emitter name."; }; non-head-bool-response-decorator: { default: CallableMessage<["operationName"]>; }; override-parameters-mismatch: { default: CallableMessage<["methodName", "checkParameter"]>; }; remove-parameter-not-found: { default: CallableMessage<["paramName", "operationName"]>; }; reorder-parameter-duplicate: { default: CallableMessage<["paramName", "operationName"]>; }; reorder-parameter-missing: { default: CallableMessage<["paramName", "operationName"]>; }; reorder-parameter-not-found: { default: CallableMessage<["paramName", "operationName"]>; }; replace-parameter-not-found: { default: CallableMessage<["paramName", "operationName"]>; }; require-versioned-service: { default: CallableMessage<["serviceName", "decoratorName"]>; }; required-parameter-scoped-out: { default: CallableMessage<["paramName", "scope"]>; }; root-client-missing-service: { default: "Root namespace decorated with @client must have service config."; }; server-param-not-path: { default: CallableMessage<["templateArgumentName", "templateArgumentType"]>; }; unexpected-http-param-type: { default: CallableMessage<["paramName", "expectedType", "actualType"]>; }; unexpected-pageable-operation-return-type: { default: "The response object for the pageable operation is either not a paging model, or is not correctly decorated with @nextLink and @pageItems."; }; union-circular: { default: "Cannot have a union containing self."; }; union-null: { default: "Cannot have a union containing only null types."; }; unsupported-generic-decorator-arg-type: { default: CallableMessage<["decoratorName"]>; }; unsupported-kind: { default: CallableMessage<["kind"]>; }; unsupported-protocol: { default: "Currently we only support HTTP and HTTPS protocols"; }; wrong-client-decorator: { default: "@client should decorate namespace or interface in client.tsp"; }; }, C, M> |