@clov-std/elysia-openapi 0.0.0-stage → 1.0.0

package/dist/openapi-types-3.2.d.ts

@@ -0,0 +1,510 @@
+/**
+ * Specification Extensions, allowed on every object that "MAY be extended".
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#specification-extensions
+ */
+export type SpecificationExtensions = Record<`x-${string}`, unknown>;
+/**
+ * Root object of an OpenAPI Description.
+ *
+ * At least one of `components`, `paths` or `webhooks` MUST be present.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#openapi-object
+ */
+export interface OpenAPIObject extends SpecificationExtensions {
+    openapi: `3.2.${number}`;
+    $self?: string;
+    info: InfoObject;
+    jsonSchemaDialect?: string;
+    servers?: ServerObject[];
+    paths?: PathsObject;
+    webhooks?: Record<string, PathItemObject>;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#info-object
+ */
+export interface InfoObject extends SpecificationExtensions {
+    title: string;
+    summary?: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#contact-object
+ */
+export interface ContactObject extends SpecificationExtensions {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+/**
+ * `identifier` and `url` are mutually exclusive.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#license-object
+ */
+export interface LicenseObject extends SpecificationExtensions {
+    name: string;
+    identifier?: string;
+    url?: string;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#server-object
+ */
+export interface ServerObject extends SpecificationExtensions {
+    url: string;
+    description?: string;
+    name?: string;
+    variables?: Record<string, ServerVariableObject>;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#server-variable-object
+ */
+export interface ServerVariableObject extends SpecificationExtensions {
+    enum?: [string, ...string[]];
+    default: string;
+    description?: string;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#components-object
+ */
+export interface ComponentsObject extends SpecificationExtensions {
+    schemas?: Record<string, SchemaObject>;
+    responses?: Record<string, ResponseObject | ReferenceObject>;
+    parameters?: Record<string, ParameterObject | ReferenceObject>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+    callbacks?: Record<string, CallbackObject | ReferenceObject>;
+    pathItems?: Record<string, PathItemObject>;
+    mediaTypes?: Record<string, MediaTypeObject | ReferenceObject>;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#paths-object
+ */
+export type PathsObject = SpecificationExtensions & Record<`/${string}`, PathItemObject>;
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#path-item-object
+ */
+export interface PathItemObject extends SpecificationExtensions {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    query?: OperationObject;
+    /**
+     * Keys are HTTP methods with the exact capitalization to send, and MUST NOT
+     * contain any method that has a fixed field (e.g. `POST`).
+     */
+    additionalOperations?: Record<string, OperationObject>;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject | ReferenceObject)[];
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#operation-object
+ */
+export interface OperationObject extends SpecificationExtensions {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses?: ResponsesObject;
+    callbacks?: Record<string, CallbackObject | ReferenceObject>;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#external-documentation-object
+ */
+export interface ExternalDocumentationObject extends SpecificationExtensions {
+    description?: string;
+    url: string;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#parameter-locations
+ */
+export type ParameterLocation = 'query' | 'querystring' | 'header' | 'path' | 'cookie';
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#style-values
+ */
+export type ParameterStyle = 'matrix' | 'label' | 'simple' | 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject' | 'cookie';
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#common-fixed-fields
+ */
+export interface ParameterObjectBase extends SpecificationExtensions {
+    name: string;
+    in: ParameterLocation;
+    description?: string;
+    /** REQUIRED and MUST be `true` when `in` is `"path"`. */
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    example?: unknown;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#fixed-fields-for-use-with-schema
+ */
+export interface ParameterObjectWithSchema extends ParameterObjectBase {
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema: SchemaObject;
+    content?: never;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#fixed-fields-for-use-with-content
+ */
+export interface ParameterObjectWithContent extends ParameterObjectBase {
+    /** MUST only contain one entry. */
+    content: Record<string, MediaTypeObject | ReferenceObject>;
+    style?: never;
+    explode?: never;
+    allowReserved?: never;
+    schema?: never;
+}
+/**
+ * A parameter MUST contain either `schema` or `content`, but not both.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#parameter-object
+ */
+export type ParameterObject = ParameterObjectWithSchema | ParameterObjectWithContent;
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#request-body-object
+ */
+export interface RequestBodyObject extends SpecificationExtensions {
+    description?: string;
+    content: Record<string, MediaTypeObject | ReferenceObject>;
+    required?: boolean;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#media-type-object
+ */
+export interface MediaTypeObject extends SpecificationExtensions {
+    schema?: SchemaObject;
+    itemSchema?: SchemaObject;
+    example?: unknown;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    encoding?: Record<string, EncodingObject>;
+    prefixEncoding?: EncodingObject[];
+    itemEncoding?: EncodingObject;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#encoding-object
+ */
+export interface EncodingObject extends SpecificationExtensions {
+    contentType?: string;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    encoding?: Record<string, EncodingObject>;
+    prefixEncoding?: EncodingObject[];
+    itemEncoding?: EncodingObject;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+/**
+ * Keys are HTTP status codes (`"200"`) or ranges (`"2XX"`).
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#responses-object
+ */
+export interface ResponsesObject extends SpecificationExtensions {
+    default?: ResponseObject | ReferenceObject;
+    [statusCode: `${1 | 2 | 3 | 4 | 5}${string}`]: ResponseObject | ReferenceObject;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#response-object
+ */
+export interface ResponseObject extends SpecificationExtensions {
+    summary?: string;
+    description?: string;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    content?: Record<string, MediaTypeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+}
+/**
+ * Keys are runtime expressions.
+ *
+ * shortcut: `x-` extensions are not typed, TS cannot exclude them from a `string` index signature
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#callback-object
+ */
+export type CallbackObject = Record<string, PathItemObject>;
+/**
+ * `dataValue` and `value` are mutually exclusive, as are `serializedValue`, `externalValue` and `value`.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#example-object
+ */
+export interface ExampleObject extends SpecificationExtensions {
+    summary?: string;
+    description?: string;
+    dataValue?: unknown;
+    serializedValue?: string;
+    externalValue?: string;
+    /** Deprecated for non-JSON serialization targets, use `dataValue` or `serializedValue` instead. */
+    value?: unknown;
+}
+/**
+ * `operationRef` and `operationId` are mutually exclusive.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#link-object
+ */
+export interface LinkObject extends SpecificationExtensions {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: Record<string, unknown>;
+    requestBody?: unknown;
+    description?: string;
+    server?: ServerObject;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#common-fixed-fields-1
+ */
+export interface HeaderObjectBase extends SpecificationExtensions {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    example?: unknown;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#fixed-fields-for-use-with-schema-0
+ */
+export interface HeaderObjectWithSchema extends HeaderObjectBase {
+    style?: 'simple';
+    explode?: boolean;
+    schema: SchemaObject;
+    content?: never;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#fixed-fields-for-use-with-content-0
+ */
+export interface HeaderObjectWithContent extends HeaderObjectBase {
+    /** MUST only contain one entry. */
+    content: Record<string, MediaTypeObject | ReferenceObject>;
+    style?: never;
+    explode?: never;
+    schema?: never;
+}
+/**
+ * A header MUST contain either `schema` or `content`, but not both.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#header-object
+ */
+export type HeaderObject = HeaderObjectWithSchema | HeaderObjectWithContent;
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#tag-object
+ */
+export interface TagObject extends SpecificationExtensions {
+    name: string;
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    parent?: string;
+    kind?: string;
+}
+/**
+ * This object cannot be extended with additional properties.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#reference-object
+ */
+export interface ReferenceObject {
+    $ref: string;
+    summary?: string;
+    description?: string;
+}
+/**
+ * @see https://json-schema.org/draft/2020-12/json-schema-validation#section-6.1.1
+ */
+export type JsonSchemaType = 'null' | 'boolean' | 'object' | 'array' | 'number' | 'string' | 'integer';
+/**
+ * JSON Schema Draft 2020-12 keywords plus the OpenAPI fixed fields.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#schema-object
+ * @see https://json-schema.org/draft/2020-12/json-schema-core
+ * @see https://json-schema.org/draft/2020-12/json-schema-validation
+ */
+export interface SchemaObjectDefinition extends SpecificationExtensions {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $anchor?: string;
+    $dynamicRef?: string;
+    $dynamicAnchor?: string;
+    $vocabulary?: Record<string, boolean>;
+    $comment?: string;
+    $defs?: Record<string, SchemaObject>;
+    allOf?: SchemaObject[];
+    anyOf?: SchemaObject[];
+    oneOf?: SchemaObject[];
+    not?: SchemaObject;
+    if?: SchemaObject;
+    then?: SchemaObject;
+    else?: SchemaObject;
+    dependentSchemas?: Record<string, SchemaObject>;
+    prefixItems?: SchemaObject[];
+    items?: SchemaObject;
+    contains?: SchemaObject;
+    properties?: Record<string, SchemaObject>;
+    patternProperties?: Record<string, SchemaObject>;
+    additionalProperties?: SchemaObject;
+    propertyNames?: SchemaObject;
+    unevaluatedItems?: SchemaObject;
+    unevaluatedProperties?: SchemaObject;
+    type?: JsonSchemaType | JsonSchemaType[];
+    enum?: unknown[];
+    const?: unknown;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxContains?: number;
+    minContains?: number;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    dependentRequired?: Record<string, string[]>;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    examples?: unknown[];
+    format?: string;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    contentSchema?: SchemaObject;
+    discriminator?: DiscriminatorObject;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    /** @deprecated Use the JSON Schema `examples` keyword instead. */
+    example?: unknown;
+}
+/**
+ * A JSON Schema 2020-12 schema, which may also be a boolean.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#schema-object
+ */
+export type SchemaObject = SchemaObjectDefinition | boolean;
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#discriminator-object
+ */
+export interface DiscriminatorObject extends SpecificationExtensions {
+    propertyName: string;
+    mapping?: Record<string, string>;
+    defaultMapping?: string;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#xml-node-types
+ */
+export type XMLNodeType = 'element' | 'attribute' | 'text' | 'cdata' | 'none';
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#xml-object
+ */
+export interface XMLObject extends SpecificationExtensions {
+    nodeType?: XMLNodeType;
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    /** @deprecated Use `nodeType: "attribute"` instead. */
+    attribute?: boolean;
+    /** @deprecated Use `nodeType: "element"` instead. */
+    wrapped?: boolean;
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#security-scheme-object
+ */
+export interface SecuritySchemeObjectBase extends SpecificationExtensions {
+    description?: string;
+    deprecated?: boolean;
+}
+export interface ApiKeySecuritySchemeObject extends SecuritySchemeObjectBase {
+    type: 'apiKey';
+    name: string;
+    in: 'query' | 'header' | 'cookie';
+}
+export interface HttpSecuritySchemeObject extends SecuritySchemeObjectBase {
+    type: 'http';
+    scheme: string;
+    /** Only applies when `scheme` is `"bearer"`. */
+    bearerFormat?: string;
+}
+export interface MutualTLSSecuritySchemeObject extends SecuritySchemeObjectBase {
+    type: 'mutualTLS';
+}
+export interface OAuth2SecuritySchemeObject extends SecuritySchemeObjectBase {
+    type: 'oauth2';
+    flows: OAuthFlowsObject;
+    oauth2MetadataUrl?: string;
+}
+export interface OpenIdConnectSecuritySchemeObject extends SecuritySchemeObjectBase {
+    type: 'openIdConnect';
+    openIdConnectUrl: string;
+}
+export type SecuritySchemeObject = ApiKeySecuritySchemeObject | HttpSecuritySchemeObject | MutualTLSSecuritySchemeObject | OAuth2SecuritySchemeObject | OpenIdConnectSecuritySchemeObject;
+/**
+ * Each flow requires its own subset of URL fields, see {@link OAuthFlowObject}.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#oauth-flows-object
+ */
+export interface OAuthFlowsObject extends SpecificationExtensions {
+    implicit?: OAuthFlowObject & {
+        authorizationUrl: string;
+    };
+    password?: OAuthFlowObject & {
+        tokenUrl: string;
+    };
+    clientCredentials?: OAuthFlowObject & {
+        tokenUrl: string;
+    };
+    authorizationCode?: OAuthFlowObject & {
+        authorizationUrl: string;
+        tokenUrl: string;
+    };
+    deviceAuthorization?: OAuthFlowObject & {
+        deviceAuthorizationUrl: string;
+        tokenUrl: string;
+    };
+}
+/**
+ * @see https://spec.openapis.org/oas/v3.2.1.html#oauth-flow-object
+ */
+export interface OAuthFlowObject extends SpecificationExtensions {
+    authorizationUrl?: string;
+    deviceAuthorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+}
+/**
+ * Keys are security scheme names (or URIs), values are required scopes or roles.
+ *
+ * @see https://spec.openapis.org/oas/v3.2.1.html#security-requirement-object
+ */
+export type SecurityRequirementObject = Record<string, string[]>;

package/dist/openapi.d.ts

@@ -0,0 +1,12 @@
+import { type AnyElysia } from 'elysia';
+import type { OpenAPIObject } from './openapi-types-3.2';
+import type { ScalarConfiguration } from './scalar-types';
+export interface OpenAPIOptions {
+    /** @default '/openapi' */
+    readonly path?: string;
+    /** @default `${path}/json` */
+    readonly specPath?: string;
+    readonly scalar?: ScalarConfiguration;
+    readonly document?: Partial<OpenAPIObject>;
+}
+export declare const openapiPlugin: ({ path, specPath, scalar, document: base }?: OpenAPIOptions) => (<const App extends AnyElysia>(host: App) => App);

package/dist/scalar-types.d.ts

@@ -0,0 +1,83 @@
+import type { ServerObject } from './openapi-types-3.2';
+/**
+ * The Scalar API reference configuration options.
+ *
+ * Only the JSON-serializable ones: the configuration is inlined in the page with `JSON.stringify`, so
+ * functions (events, `customFetch`, `plugins`, slug generators, custom sorters) would be dropped. `url` is
+ * set by the plugin.
+ */
+export interface ScalarConfiguration {
+    readonly authentication?: {
+        readonly preferredSecurityScheme?: string | readonly (string | readonly string[])[];
+        readonly securitySchemes?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+        readonly createAnySecurityScheme?: boolean;
+    };
+    readonly agent?: {
+        readonly key?: string;
+        readonly disabled?: boolean;
+    };
+    readonly baseServerURL?: string;
+    readonly customCss?: string;
+    readonly darkMode?: boolean;
+    readonly defaultHttpClient?: {
+        readonly targetKey: string;
+        readonly clientKey: string;
+    };
+    readonly defaultOpenAllTags?: boolean;
+    readonly defaultOpenFirstTag?: boolean;
+    readonly defaultRequestBodyView?: 'form' | 'raw';
+    readonly documentDownloadType?: 'json' | 'yaml' | 'both' | 'direct' | 'none';
+    readonly expandAllModelSections?: boolean;
+    readonly expandAllParameters?: boolean;
+    readonly expandAllResponses?: boolean;
+    readonly expandAllSchemaProperties?: boolean;
+    readonly favicon?: string;
+    /** `target/client` ids, like `shell/curl` */
+    readonly featuredClients?: readonly string[];
+    readonly forceDarkModeState?: 'dark' | 'light';
+    readonly hiddenClients?: true | readonly string[] | Readonly<Record<string, boolean | readonly string[]>>;
+    readonly hideClientButton?: boolean;
+    readonly hideDarkModeToggle?: boolean;
+    readonly hideModelNames?: boolean;
+    readonly hideModels?: boolean;
+    readonly hideSearch?: boolean;
+    readonly hideTestRequestButton?: boolean;
+    readonly isEditable?: boolean;
+    readonly layout?: 'modern' | 'classic';
+    readonly localization?: {
+        readonly locale?: string;
+        readonly direction?: 'ltr' | 'rtl' | 'auto';
+        readonly translations?: Readonly<Record<string, unknown>>;
+    };
+    readonly maxVisibleRequestBodyProperties?: number;
+    readonly mcp?: {
+        readonly name?: string;
+        readonly url?: string;
+        readonly disabled?: boolean;
+    };
+    readonly metaData?: Readonly<Record<string, string>>;
+    readonly modelsSectionLabel?: string;
+    readonly oauth2RedirectUri?: string;
+    readonly operationsSorter?: 'alpha' | 'method';
+    readonly operationTitleSource?: 'summary' | 'path';
+    readonly orderRequiredPropertiesFirst?: boolean;
+    readonly orderSchemaPropertiesBy?: 'alpha' | 'preserve';
+    readonly pathRouting?: {
+        readonly basePath: string;
+    };
+    readonly persistAuth?: boolean;
+    /** ESM modules default-exporting a plugin */
+    readonly pluginUrls?: readonly string[];
+    readonly proxyUrl?: string;
+    readonly schemaKeyboardNav?: boolean;
+    readonly searchHotKey?: string;
+    readonly servers?: readonly ServerObject[];
+    readonly showDeveloperTools?: 'always' | 'localhost' | 'never';
+    readonly showExtensions?: readonly `x-${string}`[];
+    readonly showOperationId?: boolean;
+    readonly showSidebar?: boolean;
+    readonly tagsSorter?: 'alpha';
+    readonly telemetry?: boolean;
+    readonly theme?: 'alternate' | 'bluePlanet' | 'deepSpace' | 'default' | 'elysiajs' | 'fastify' | 'kepler' | 'laserwave' | 'mars' | 'moon' | 'none' | 'purple' | 'saturn' | 'solarized';
+    readonly withDefaultFonts?: boolean;
+}

package/dist/schema.d.ts

@@ -0,0 +1,50 @@
+import type { AnySchema } from 'elysia';
+import type { SchemaObject } from './openapi-types-3.2';
+export type Models = Record<string, AnySchema>;
+/** A hook schema, or the name of a model (`body: 'User'`). */
+export type HookSchema = AnySchema | string;
+/** Named properties a schema accepts, see {@link objectShapeOf}. */
+export interface ObjectShape {
+    readonly properties: Readonly<Record<string, unknown>>;
+    readonly required: ReadonlySet<string>;
+}
+export declare const uniqueSchemas: <T>(schemas: readonly T[]) => T[];
+/**
+ * Converts a TypeBox schema to a plain JSON Schema 2020-12, without mutating it.
+ *
+ * TypeBox schemas already are JSON Schema, only Elysia's custom kinds and model references need rewriting.
+ */
+export declare const toSchema: (node: unknown) => unknown;
+/**
+ * Attaches response headers to a response schema, documented as the response's `headers`.
+ *
+ * Elysia does not validate response headers, this is documentation only.
+ *
+ * @param schema - The response body schema
+ * @param headers - An object schema of the headers
+ *
+ * @returns A copy of `schema` carrying `headers`
+ */
+export declare const withHeaders: <const Schema extends AnySchema>(schema: Schema, headers: AnySchema) => Schema;
+export declare const toRootSchema: (node: unknown) => SchemaObject;
+/** The schema behind a model name (`'User'`) or a `t.Ref('User')`. */
+export declare const resolveModel: (node: unknown, models: Models) => AnySchema | undefined;
+/** The JSON Schema `type` keyword, whatever the TypeBox kind (`t.Literal('a')` is a `string`). */
+export declare const jsonTypeOf: (node: AnySchema | undefined) => unknown;
+export declare const descriptionOf: (node: AnySchema | undefined) => string | undefined;
+export declare const hasDefault: (node: AnySchema | undefined) => boolean;
+/** Whether Elysia sends every value of the schema as text (strings, numbers, booleans). */
+export declare const isText: (node: unknown, models: Models) => boolean;
+/** Whether every value of the schema is a JSON primitive or `null`. */
+export declare const isPrimitive: (node: unknown, models: Models) => boolean;
+/** `t.ArrayBuffer()` and `t.Uint8Array()`, read by Elysia from an `application/octet-stream` body. */
+export declare const isRawBinary: (node: unknown) => boolean;
+export declare const isFile: (node: unknown) => boolean;
+export declare const containsFile: (node: unknown, models: Models, seen?: Set<unknown>) => boolean;
+/**
+ * The named properties a schema accepts: an object, a model (`'Page'`, `t.Ref('Page')`), or a union or intersection
+ * of them.
+ *
+ * A union's property is required when every branch requires it, an intersection's when any does.
+ */
+export declare const objectShapeOf: (node: unknown, models: Models) => ObjectShape | undefined;