[V] $lib

const $lib: TypeSpecLibrary<{
  api-version-not-string: {
     default: "Api version must be a string or a string enum";
    };
  client-service: {
     default: CallableMessage<["name"]>;
    };
  conflict-access-override: {
     default: "@access override conflicts with the access calculated from operation or other @access override.";
    };
  conflict-usage-override: {
     default: "@usage override conflicts with the usage calculated from operation or other @usage 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-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"]>;
    };
  flatten-polymorphism: {
     default: "Cannot flatten property of polymorphic type.";
    };
  invalid-access: {
     default: "Access value must be \"public\" or \"internal\".";
    };
  invalid-alternate-type: {
     default: CallableMessage<["kindName"]>;
    };
  invalid-client-doc-mode: {
     default: CallableMessage<["mode"]>;
    };
  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-usage: {
     default: "Usage value must be 2 (\"input\") or 4 (\"output\").";
    };
  missing-service-versions: {
     default: CallableMessage<["serviceName", "missingVersions"]>;
    };
  multiple-response-types: {
     default: CallableMessage<["operation", "response"]>;
    };
  multiple-services: {
     default: "Multiple services found. Only the first service will be used; others will be ignored.";
    };
  no-corresponding-method-param: {
     default: CallableMessage<["paramName", "methodName"]>;
    };
  no-discriminated-unions: {
     default: "Discriminated unions are not supported. Please redefine the type using model with hierarchy and `@discriminator` decorator.";
    };
  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", "originalParameters", "overrideParameters"]>;
    };
  require-versioned-service: {
     default: CallableMessage<["serviceName", "decoratorName"]>;
    };
  server-param-not-path: {
     default: CallableMessage<["templateArgumentName", "templateArgumentType"]>;
    };
  unexpected-http-param-type: {
     default: CallableMessage<["paramName", "expectedType", "actualType"]>;
    };
  unexpected-pageable-operation-return-type: {
     default: "Operation is pageable but does not return a correct type.";
    };
  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-http-file-body: {
     default: "File body is not supported for HTTP operations. Please use bytes instead.";
    };
  unsupported-kind: {
     default: CallableMessage<["kind"]>;
    };
  unsupported-protocol: {
     default: "Currently we only support HTTP and HTTPS protocols";
    };
  wrong-client-decorator: {
     default: "@client or @operationGroup should decorate namespace or interface in client.tsp";
    };
}, TCGCEmitterOptions, never>;