@typespec/http 0.41.0

package/dist/src/lib.d.ts

@@ -0,0 +1,294 @@
+declare const httpLib: import("@typespec/compiler").TypeSpecLibrary<{
+    "http-verb-duplicate": {
+        readonly default: import("@typespec/compiler").CallableMessage<["entityName"]>;
+    };
+    "http-verb-wrong-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["verb", "entityKind"]>;
+    };
+    "missing-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "optional-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName"]>;
+    };
+    "missing-server-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "duplicate-body": {
+        readonly default: "Operation has multiple @body parameters declared";
+        readonly duplicateUnannotated: "Operation has multiple unannotated parameters. There can only be one representing the body";
+        readonly bodyAndUnannotated: "Operation has a @body and an unannotated parameter. There can only be one representing the body";
+    };
+    "duplicate-route-decorator": {
+        readonly namespace: "@route was defined twice on this namespace and has different values.";
+    };
+    "operation-param-duplicate-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName", "types"]>;
+    };
+    "duplicate-operation": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationName", "verb", "path"]>;
+    };
+    "status-code-invalid": {
+        readonly default: "statusCode value must be a numeric or string literal or union of numeric or string literals";
+        readonly value: "statusCode value must be a three digit code between 100 and 599";
+    };
+    "content-type-string": {
+        readonly default: "contentType parameter must be a string literal or union of string literals";
+    };
+    "duplicate-response": {
+        readonly default: import("@typespec/compiler").CallableMessage<["contentType", "statusCode"]>;
+    };
+    "content-type-ignored": {
+        readonly default: "`Content-Type` header ignored because there is no body.";
+    };
+    "no-routes": {
+        readonly default: "Current spec is not exposing any routes. This could be to not having the service namespace marked with @service.";
+    };
+    "invalid-type-for-auth": {
+        readonly default: import("@typespec/compiler").CallableMessage<["kind"]>;
+    };
+    "shared-boolean": {
+        readonly default: "shared parameter must be a boolean.";
+    };
+    "write-visibility-not-supported": {
+        readonly default: "@visibility(\"write\") is not supported. Use @visibility(\"update\"), @visibility(\"create\") or @visibility(\"create\", \"update\") as appropriate.";
+    };
+    "multipart-model": {
+        readonly default: "Multipart request body must be a model.";
+    };
+}, Record<string, any>>;
+declare const reportDiagnostic: <C extends "http-verb-duplicate" | "http-verb-wrong-type" | "missing-path-param" | "optional-path-param" | "missing-server-param" | "duplicate-body" | "duplicate-route-decorator" | "operation-param-duplicate-type" | "duplicate-operation" | "status-code-invalid" | "content-type-string" | "duplicate-response" | "content-type-ignored" | "no-routes" | "invalid-type-for-auth" | "shared-boolean" | "write-visibility-not-supported" | "multipart-model", M extends keyof {
+    "http-verb-duplicate": {
+        readonly default: import("@typespec/compiler").CallableMessage<["entityName"]>;
+    };
+    "http-verb-wrong-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["verb", "entityKind"]>;
+    };
+    "missing-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "optional-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName"]>;
+    };
+    "missing-server-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "duplicate-body": {
+        readonly default: "Operation has multiple @body parameters declared";
+        readonly duplicateUnannotated: "Operation has multiple unannotated parameters. There can only be one representing the body";
+        readonly bodyAndUnannotated: "Operation has a @body and an unannotated parameter. There can only be one representing the body";
+    };
+    "duplicate-route-decorator": {
+        readonly namespace: "@route was defined twice on this namespace and has different values.";
+    };
+    "operation-param-duplicate-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName", "types"]>;
+    };
+    "duplicate-operation": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationName", "verb", "path"]>;
+    };
+    "status-code-invalid": {
+        readonly default: "statusCode value must be a numeric or string literal or union of numeric or string literals";
+        readonly value: "statusCode value must be a three digit code between 100 and 599";
+    };
+    "content-type-string": {
+        readonly default: "contentType parameter must be a string literal or union of string literals";
+    };
+    "duplicate-response": {
+        readonly default: import("@typespec/compiler").CallableMessage<["contentType", "statusCode"]>;
+    };
+    "content-type-ignored": {
+        readonly default: "`Content-Type` header ignored because there is no body.";
+    };
+    "no-routes": {
+        readonly default: "Current spec is not exposing any routes. This could be to not having the service namespace marked with @service.";
+    };
+    "invalid-type-for-auth": {
+        readonly default: import("@typespec/compiler").CallableMessage<["kind"]>;
+    };
+    "shared-boolean": {
+        readonly default: "shared parameter must be a boolean.";
+    };
+    "write-visibility-not-supported": {
+        readonly default: "@visibility(\"write\") is not supported. Use @visibility(\"update\"), @visibility(\"create\") or @visibility(\"create\", \"update\") as appropriate.";
+    };
+    "multipart-model": {
+        readonly default: "Multipart request body must be a model.";
+    };
+}[C]>(program: import("@typespec/compiler").Program, diag: import("@typespec/compiler").DiagnosticReport<{
+    "http-verb-duplicate": {
+        readonly default: import("@typespec/compiler").CallableMessage<["entityName"]>;
+    };
+    "http-verb-wrong-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["verb", "entityKind"]>;
+    };
+    "missing-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "optional-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName"]>;
+    };
+    "missing-server-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "duplicate-body": {
+        readonly default: "Operation has multiple @body parameters declared";
+        readonly duplicateUnannotated: "Operation has multiple unannotated parameters. There can only be one representing the body";
+        readonly bodyAndUnannotated: "Operation has a @body and an unannotated parameter. There can only be one representing the body";
+    };
+    "duplicate-route-decorator": {
+        readonly namespace: "@route was defined twice on this namespace and has different values.";
+    };
+    "operation-param-duplicate-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName", "types"]>;
+    };
+    "duplicate-operation": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationName", "verb", "path"]>;
+    };
+    "status-code-invalid": {
+        readonly default: "statusCode value must be a numeric or string literal or union of numeric or string literals";
+        readonly value: "statusCode value must be a three digit code between 100 and 599";
+    };
+    "content-type-string": {
+        readonly default: "contentType parameter must be a string literal or union of string literals";
+    };
+    "duplicate-response": {
+        readonly default: import("@typespec/compiler").CallableMessage<["contentType", "statusCode"]>;
+    };
+    "content-type-ignored": {
+        readonly default: "`Content-Type` header ignored because there is no body.";
+    };
+    "no-routes": {
+        readonly default: "Current spec is not exposing any routes. This could be to not having the service namespace marked with @service.";
+    };
+    "invalid-type-for-auth": {
+        readonly default: import("@typespec/compiler").CallableMessage<["kind"]>;
+    };
+    "shared-boolean": {
+        readonly default: "shared parameter must be a boolean.";
+    };
+    "write-visibility-not-supported": {
+        readonly default: "@visibility(\"write\") is not supported. Use @visibility(\"update\"), @visibility(\"create\") or @visibility(\"create\", \"update\") as appropriate.";
+    };
+    "multipart-model": {
+        readonly default: "Multipart request body must be a model.";
+    };
+}, C, M>) => void, createDiagnostic: <C extends "http-verb-duplicate" | "http-verb-wrong-type" | "missing-path-param" | "optional-path-param" | "missing-server-param" | "duplicate-body" | "duplicate-route-decorator" | "operation-param-duplicate-type" | "duplicate-operation" | "status-code-invalid" | "content-type-string" | "duplicate-response" | "content-type-ignored" | "no-routes" | "invalid-type-for-auth" | "shared-boolean" | "write-visibility-not-supported" | "multipart-model", M extends keyof {
+    "http-verb-duplicate": {
+        readonly default: import("@typespec/compiler").CallableMessage<["entityName"]>;
+    };
+    "http-verb-wrong-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["verb", "entityKind"]>;
+    };
+    "missing-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "optional-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName"]>;
+    };
+    "missing-server-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "duplicate-body": {
+        readonly default: "Operation has multiple @body parameters declared";
+        readonly duplicateUnannotated: "Operation has multiple unannotated parameters. There can only be one representing the body";
+        readonly bodyAndUnannotated: "Operation has a @body and an unannotated parameter. There can only be one representing the body";
+    };
+    "duplicate-route-decorator": {
+        readonly namespace: "@route was defined twice on this namespace and has different values.";
+    };
+    "operation-param-duplicate-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName", "types"]>;
+    };
+    "duplicate-operation": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationName", "verb", "path"]>;
+    };
+    "status-code-invalid": {
+        readonly default: "statusCode value must be a numeric or string literal or union of numeric or string literals";
+        readonly value: "statusCode value must be a three digit code between 100 and 599";
+    };
+    "content-type-string": {
+        readonly default: "contentType parameter must be a string literal or union of string literals";
+    };
+    "duplicate-response": {
+        readonly default: import("@typespec/compiler").CallableMessage<["contentType", "statusCode"]>;
+    };
+    "content-type-ignored": {
+        readonly default: "`Content-Type` header ignored because there is no body.";
+    };
+    "no-routes": {
+        readonly default: "Current spec is not exposing any routes. This could be to not having the service namespace marked with @service.";
+    };
+    "invalid-type-for-auth": {
+        readonly default: import("@typespec/compiler").CallableMessage<["kind"]>;
+    };
+    "shared-boolean": {
+        readonly default: "shared parameter must be a boolean.";
+    };
+    "write-visibility-not-supported": {
+        readonly default: "@visibility(\"write\") is not supported. Use @visibility(\"update\"), @visibility(\"create\") or @visibility(\"create\", \"update\") as appropriate.";
+    };
+    "multipart-model": {
+        readonly default: "Multipart request body must be a model.";
+    };
+}[C]>(diag: import("@typespec/compiler").DiagnosticReport<{
+    "http-verb-duplicate": {
+        readonly default: import("@typespec/compiler").CallableMessage<["entityName"]>;
+    };
+    "http-verb-wrong-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["verb", "entityKind"]>;
+    };
+    "missing-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "optional-path-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName"]>;
+    };
+    "missing-server-param": {
+        readonly default: import("@typespec/compiler").CallableMessage<["param"]>;
+    };
+    "duplicate-body": {
+        readonly default: "Operation has multiple @body parameters declared";
+        readonly duplicateUnannotated: "Operation has multiple unannotated parameters. There can only be one representing the body";
+        readonly bodyAndUnannotated: "Operation has a @body and an unannotated parameter. There can only be one representing the body";
+    };
+    "duplicate-route-decorator": {
+        readonly namespace: "@route was defined twice on this namespace and has different values.";
+    };
+    "operation-param-duplicate-type": {
+        readonly default: import("@typespec/compiler").CallableMessage<["paramName", "types"]>;
+    };
+    "duplicate-operation": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationName", "verb", "path"]>;
+    };
+    "status-code-invalid": {
+        readonly default: "statusCode value must be a numeric or string literal or union of numeric or string literals";
+        readonly value: "statusCode value must be a three digit code between 100 and 599";
+    };
+    "content-type-string": {
+        readonly default: "contentType parameter must be a string literal or union of string literals";
+    };
+    "duplicate-response": {
+        readonly default: import("@typespec/compiler").CallableMessage<["contentType", "statusCode"]>;
+    };
+    "content-type-ignored": {
+        readonly default: "`Content-Type` header ignored because there is no body.";
+    };
+    "no-routes": {
+        readonly default: "Current spec is not exposing any routes. This could be to not having the service namespace marked with @service.";
+    };
+    "invalid-type-for-auth": {
+        readonly default: import("@typespec/compiler").CallableMessage<["kind"]>;
+    };
+    "shared-boolean": {
+        readonly default: "shared parameter must be a boolean.";
+    };
+    "write-visibility-not-supported": {
+        readonly default: "@visibility(\"write\") is not supported. Use @visibility(\"update\"), @visibility(\"create\") or @visibility(\"create\", \"update\") as appropriate.";
+    };
+    "multipart-model": {
+        readonly default: "Multipart request body must be a model.";
+    };
+}, C, M>) => import("@typespec/compiler").Diagnostic, createStateSymbol: (name: string) => symbol;
+export { httpLib, reportDiagnostic, createDiagnostic, createStateSymbol };
+//# sourceMappingURL=lib.d.ts.map

package/dist/src/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"AA2HA,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAuC,CAAC;AACrD,QAAA,MAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAAE,iBAAiB,0BAAY,CAAC;AAE1E,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/src/lib.js

@@ -0,0 +1,121 @@
+import { createTypeSpecLibrary, paramMessage } from "@typespec/compiler";
+const libDefinition = {
+    name: "@typespec/http",
+    diagnostics: {
+        "http-verb-duplicate": {
+            severity: "error",
+            messages: {
+                default: paramMessage `HTTP verb already applied to ${"entityName"}`,
+            },
+        },
+        "http-verb-wrong-type": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Cannot use @${"verb"} on a ${"entityKind"}`,
+            },
+        },
+        "missing-path-param": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Path contains parameter ${"param"} but wasn't found in given parameters`,
+            },
+        },
+        "optional-path-param": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Path parameter '${"paramName"}' cannot be optional.`,
+            },
+        },
+        "missing-server-param": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Server url contains parameter '${"param"}' but wasn't found in given parameters`,
+            },
+        },
+        "duplicate-body": {
+            severity: "error",
+            messages: {
+                default: "Operation has multiple @body parameters declared",
+                duplicateUnannotated: "Operation has multiple unannotated parameters. There can only be one representing the body",
+                bodyAndUnannotated: "Operation has a @body and an unannotated parameter. There can only be one representing the body",
+            },
+        },
+        "duplicate-route-decorator": {
+            severity: "error",
+            messages: {
+                namespace: "@route was defined twice on this namespace and has different values.",
+            },
+        },
+        "operation-param-duplicate-type": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Param ${"paramName"} has multiple types: [${"types"}]`,
+            },
+        },
+        "duplicate-operation": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Duplicate operation "${"operationName"}" routed at "${"verb"} ${"path"}".`,
+            },
+        },
+        "status-code-invalid": {
+            severity: "error",
+            messages: {
+                default: "statusCode value must be a numeric or string literal or union of numeric or string literals",
+                value: "statusCode value must be a three digit code between 100 and 599",
+            },
+        },
+        "content-type-string": {
+            severity: "error",
+            messages: {
+                default: "contentType parameter must be a string literal or union of string literals",
+            },
+        },
+        "duplicate-response": {
+            severity: "error",
+            messages: {
+                default: paramMessage `Multiple return types for content type ${"contentType"} and status code ${"statusCode"}`,
+            },
+        },
+        "content-type-ignored": {
+            severity: "warning",
+            messages: {
+                default: "`Content-Type` header ignored because there is no body.",
+            },
+        },
+        "no-routes": {
+            severity: "warning",
+            messages: {
+                default: "Current spec is not exposing any routes. This could be to not having the service namespace marked with @service.",
+            },
+        },
+        "invalid-type-for-auth": {
+            severity: "error",
+            messages: {
+                default: paramMessage `@useAuth ${"kind"} only accept Auth model, Tuple of auth model or union of auth model.`,
+            },
+        },
+        "shared-boolean": {
+            severity: "error",
+            messages: {
+                default: "shared parameter must be a boolean.",
+            },
+        },
+        "write-visibility-not-supported": {
+            severity: "warning",
+            messages: {
+                default: `@visibility("write") is not supported. Use @visibility("update"), @visibility("create") or @visibility("create", "update") as appropriate.`,
+            },
+        },
+        "multipart-model": {
+            severity: "error",
+            messages: {
+                default: "Multipart request body must be a model.",
+            },
+        },
+    },
+};
+const httpLib = createTypeSpecLibrary(libDefinition);
+const { reportDiagnostic, createDiagnostic, createStateSymbol } = httpLib;
+export { httpLib, reportDiagnostic, createDiagnostic, createStateSymbol };
+//# sourceMappingURL=lib.js.map

package/dist/src/lib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.js","sourceRoot":"","sources":["../../src/lib.ts"],"names":[],"mappings":"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"}

package/dist/src/metadata.d.ts

@@ -0,0 +1,129 @@
+import { DiagnosticCollector, ModelProperty, Program, Type } from "@typespec/compiler";
+import { HttpVerb } from "./types.js";
+/**
+ * Flags enum representation of well-known visibilities that are used in
+ * REST API.
+ */
+export declare enum Visibility {
+    Read = 1,
+    Create = 2,
+    Update = 4,
+    Delete = 8,
+    Query = 16,
+    All = 31,
+    /**
+     * Additional flag to indicate when something is nested in a collection
+     * and therefore no metadata is applicable.
+     */
+    Item = 1048576
+}
+/**
+ * Provides a naming suffix to create a unique name for a type with this
+ * visibility.
+ *
+ * `Visibility.All` gets empty suffix, otherwise visibilities are joined in
+ * pascal-case with `Or`. And `Item` is if `Visibility.Item` is produced.
+ *
+ * Examples:
+ *  - Visibility.All => ""
+ *  - Visibility.Read => "Read"
+ *  - Visibility.Create | Visibility.Update => "CreateOrUpdate"
+ *  - Visibility.Create | Visibility.Item => "CreateItem"
+ *  - Visibility.Create | Visibility.Update | Visibility.Item =>  "CreateOrUpdateItem"
+ *  */
+export declare function getVisibilitySuffix(visibility: Visibility): string;
+/**
+ * Determines the visibility to use for a request with the given verb.
+ *
+ * - GET | HEAD => Visibility.Query
+ * - POST => Visibility.Update
+ * - PUT => Visibility.Create | Update
+ * - DELETE => Visibility.Delete
+ */
+export declare function getRequestVisibility(verb: HttpVerb): Visibility;
+/**
+ * Walks the given type and collects all applicable metadata and `@body`
+ * properties recursively.
+ */
+export declare function gatherMetadata(program: Program, diagnostics: DiagnosticCollector, // currently unused, but reserved for future diagnostics
+type: Type, visibility: Visibility, isMetadataCallback?: typeof isMetadata): Set<ModelProperty>;
+/**
+ * Determines if a property is metadata. A property is defined to be
+ * metadata if it is marked `@header`, `@query`, `@path`, or `@statusCode`.
+ */
+export declare function isMetadata(program: Program, property: ModelProperty): boolean;
+/**
+ * Determines if the given property is visible with the given visibility.
+ */
+export declare function isVisible(program: Program, property: ModelProperty, visibility: Visibility): boolean;
+/**
+ * Determines if the given property is metadata that is applicable with the
+ * given visibility.
+ *
+ * - No metadata is applicable with Visibility.Item present.
+ * - If only Visibility.Read is present, then only `@header` and `@status`
+ *   properties are applicable.
+ * - If Visibility.Read is not present, all metadata properties other than
+ *   `@statusCode` are applicable.
+ */
+export declare function isApplicableMetadata(program: Program, property: ModelProperty, visibility: Visibility, isMetadataCallback?: typeof isMetadata): boolean;
+/**
+ * Determines if the given property is metadata or marked `@body` and
+ * applicable with the given visibility.
+ */
+export declare function isApplicableMetadataOrBody(program: Program, property: ModelProperty, visibility: Visibility, isMetadataCallback?: typeof isMetadata): boolean;
+/**
+ * Provides information about changes that happen to a data type's payload
+ * when inapplicable metadata is added or invisible properties are removed.
+ *
+ * Results are computed on demand and expensive computations are memoized.
+ */
+export interface MetadataInfo {
+    /**
+     * Determines if the given type is a model that becomes empty once
+     * applicable metadata is removed and visibility is applied.
+     *
+     * Note that a model is not considered emptied if it was already empty in
+     * the first place, or has a base model or indexer.
+     *
+     * When the type of a property is emptied by visibility, the property
+     * itself is also removed.
+     */
+    isEmptied(type: Type | undefined, visibility: Visibility): boolean;
+    /**
+     * Determines if the given type is transformed by applying the given
+     * visibility and removing invisible properties or adding inapplicable
+     * metadata properties.
+     */
+    isTransformed(type: Type | undefined, visibility: Visibility): boolean;
+    /**
+     * Determines if the given property is part of the request or response
+     * payload and not applicable metadata (@see isApplicableMetadata) or
+     * filtered out by the given visibility.
+     */
+    isPayloadProperty(property: ModelProperty, visibility: Visibility): boolean;
+    /**
+     * Determines if the given property is optional in the request or
+     * response payload for the given visibility.
+     */
+    isOptional(property: ModelProperty, visibility: Visibility): boolean;
+    /**
+     * If type is an anonymous model, tries to find a named model that has the
+     * same set of properties when non-payload properties are excluded.
+     */
+    getEffectivePayloadType(type: Type, visibility: Visibility): Type;
+}
+export interface MetadataInfoOptions {
+    /**
+     * Optional callback to indicate that a property can be shared with
+     * `Visibility.All` representation even for visibilities where it is not
+     * visible.
+     *
+     * This is used, for example, in OpenAPI emit where a property can be
+     * marked `readOnly: true` to represent @visibility("read") without
+     * creating a separate schema schema for Visibility.Read.
+     */
+    canShareProperty?(property: ModelProperty): boolean;
+}
+export declare function createMetadataInfo(program: Program, options?: MetadataInfoOptions): MetadataInfo;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/src/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,mBAAmB,EAInB,aAAa,EACb,OAAO,EAGP,IAAI,EAGL,MAAM,oBAAoB,CAAC;AAS5B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;GAGG;AACH,oBAAY,UAAU;IACpB,IAAI,IAAS;IACb,MAAM,IAAS;IACf,MAAM,IAAS;IACf,MAAM,IAAS;IACf,KAAK,KAAS;IAEd,GAAG,KAA0C;IAE7C;;;OAGG;IACH,IAAI,UAAU;CACf;AAkCD;;;;;;;;;;;;;MAaM;AACN,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,UAAU,UAazD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAiB/D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,mBAAmB,EAAE,wDAAwD;AAC1F,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,UAAU,EACtB,kBAAkB,oBAAa,GAC9B,GAAG,CAAC,aAAa,CAAC,CA4CpB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,WAOnE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,WAE1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,UAAU,EACtB,kBAAkB,oBAAa,WAGhC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,UAAU,EACtB,kBAAkB,oBAAa,WAGhC;AAgCD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;OASG;IACH,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC;IAEnE;;;;OAIG;IACH,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC;IAEvE;;;;OAIG;IACH,iBAAiB,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC;IAE5E;;;OAGG;IACH,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC;IAErE;;;OAGG;IACH,uBAAuB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;CACnE;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;OAQG;IACH,gBAAgB,CAAC,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC;CACrD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,CAsKhG"}