@power-plant/schema 0.0.39 → 0.0.41

package/dist/deepkit.d.mts

@@ -1 +1,644 @@
-export * from "@deepkit/type-compiler";
+import ts, { ArrowFunction, Bundle, ClassDeclaration, ClassExpression, CompilerHost, CompilerOptions, ConstructorDeclaration, CustomTransformer, CustomTransformerFactory, Declaration, EntityName, ExportDeclaration, Expression, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, Identifier, ImportDeclaration, JSDocImportTag, MethodDeclaration, ModuleDeclaration, ModuleExportName, Node, NodeArray, NodeFactory, ParseConfigHost, PropertyAccessExpression, QualifiedName, ResolvedModule, ScriptKind, SourceFile, Statement, StringLiteral, Symbol as Symbol$1, SymbolTable, TransformationContext, TypeAliasDeclaration, TypeChecker, TypeParameterDeclaration, TypeReferenceNode } from "typescript";
+import { ReflectionOp } from "@deepkit/type-spec";
+import { TypeAnnotation } from "@deepkit/core";
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/ts-types.d.ts
+/**
+ * Contains @internal properties that are not yet in the public API of TS.
+ */
+interface SourceFile$1 extends SourceFile {
+  /**
+   * If two source files are for the same version of the same package, one will redirect to the other.
+   * (See `createRedirectSourceFile` in program.ts.)
+   * The redirect will have this set. The redirected-to source file will be in `redirectTargetsMap`.
+   */
+  redirectInfo?: any;
+  scriptKind?: ScriptKind;
+  externalModuleIndicator?: Node;
+  commonJsModuleIndicator?: Node;
+  jsGlobalAugmentations?: SymbolTable;
+  symbol?: Symbol$1;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/reflection-ast.d.ts
+type PackExpression = Expression | string | number | boolean | bigint;
+type JSDocTagValue = string | boolean;
+declare class NodeConverter {
+  protected f: NodeFactory;
+  constructor(f: NodeFactory);
+  toExpression<T extends PackExpression | PackExpression[]>(node?: T): Expression;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/resolver.d.ts
+/**
+ * A utility to resolve a module path and its declaration.
+ *
+ * It automatically reads a SourceFile, binds and caches it.
+ */
+declare class Resolver {
+  compilerOptions: CompilerOptions;
+  host: CompilerHost;
+  protected sourceFiles: {
+    [fileName: string]: SourceFile;
+  };
+  constructor(compilerOptions: CompilerOptions, host: CompilerHost, sourceFiles: {
+    [fileName: string]: SourceFile;
+  });
+  resolve(from: SourceFile, importOrExportNode: ExportDeclaration | ImportDeclaration | JSDocImportTag): SourceFile | undefined;
+  protected resolveImpl(modulePath: StringLiteral, sourceFile: SourceFile): ResolvedModule | undefined;
+  /**
+   * Tries to resolve the .ts/d.ts file path for a given module path.
+   * Scans relative paths. Looks into package.json "types" and "exports" (with new 4.7 support)
+   *
+   * @param sourceFile the SourceFile of the file that contains the import. modulePath is relative to that.
+   * @param modulePath the x in 'from x'.
+   */
+  resolveSourceFile(sourceFile: SourceFile, modulePath: StringLiteral): SourceFile | undefined;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/config.d.ts
+/**
+ * Default means reflection is enabled for this file.
+ * Never means the whole reflection is disabled for this file.
+ * Explicit means that reflection is per default disabled for this file, but each symbol/type
+ * in it is allowed to enable it using jsdoc `@reflection`.
+ */
+declare const reflectionModes: readonly ["default", "explicit", "never"];
+type Mode = (typeof reflectionModes)[number];
+interface ReflectionConfig {
+  /**
+   * Allows to exclude type definitions/TS files from being included in the type compilation step.
+   * When a global .d.ts is matched, their types won't be embedded (useful to exclude DOM for example)
+   */
+  exclude?: string[];
+  /**
+   * Either a boolean indication general reflection mode,
+   * or a list of globs to match against.
+   */
+  reflection?: string[] | Mode;
+}
+interface ResolvedConfig extends ReflectionConfig {
+  path: string;
+  compilerOptions: ts.CompilerOptions;
+  mergeStrategy: 'merge' | 'replace';
+}
+interface MatchResult {
+  tsConfigPath: string;
+  mode: (typeof reflectionModes)[number];
+}
+type Matcher = (path: string) => MatchResult;
+type ConfigResolver = {
+  match: Matcher;
+  config: ResolvedConfig;
+};
+type ReflectionConfigCache = {
+  [path: string]: ConfigResolver;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/compiler.d.ts
+declare function encodeOps(ops: ReflectionOp[]): string;
+declare const packSizeByte: number;
+/**
+ * It can't be more ops than this given number
+ */
+declare const packSize: number;
+declare function debugPackStruct(sourceFile: SourceFile$1, forType: Node, pack: {
+  ops: ReflectionOp[];
+  stack: PackExpression[];
+}): void;
+interface Frame {
+  variables: {
+    name: string;
+    index: number;
+  }[];
+  opIndex: number;
+  conditional?: true;
+  previous?: Frame;
+}
+type StackEntry = Expression | string | number | boolean;
+declare class CompilerProgram {
+  forNode: Node;
+  sourceFile?: SourceFile$1;
+  protected ops: ReflectionOp[];
+  protected stack: StackEntry[];
+  protected mainOffset: number;
+  protected stackPosition: number;
+  protected frame: Frame;
+  protected activeCoRoutines: {
+    ops: ReflectionOp[];
+  }[];
+  protected coRoutines: {
+    ops: ReflectionOp[];
+  }[];
+  constructor(forNode: Node, sourceFile?: SourceFile$1);
+  buildPackStruct(): {
+    ops: ReflectionOp[];
+    stack: StackEntry[];
+  };
+  isEmpty(): boolean;
+  pushConditionalFrame(): void;
+  pushStack(item: StackEntry): number;
+  pushCoRoutine(): void;
+  popCoRoutine(): number;
+  pushOp(...ops: ReflectionOp[]): void;
+  pushOpAtFrame(frame: Frame, ...ops: ReflectionOp[]): void;
+  /**
+   * Returns the index of the `entry` in the stack, if already exists. If not, add it, and return that new index.
+   */
+  findOrAddStackEntry(entry: any): number;
+  /**
+   * To make room for a stack entry expected on the stack as input for example.
+   */
+  increaseStackPosition(): number;
+  protected resolveFunctionParameters: Map<ts.Node, number>;
+  resolveFunctionParametersIncrease(fn: Node): void;
+  resolveFunctionParametersDecrease(fn: Node): void;
+  isResolveFunctionParameters(fn: Node): boolean;
+  /**
+   *
+   * Each pushFrame() call needs a popFrame() call.
+   */
+  pushFrame(implicit?: boolean): Frame;
+  findConditionalFrame(): Frame;
+  /**
+   * Remove stack without doing it as OP in the processor. Some other command calls popFrame() already, which makes popFrameImplicit() an implicit popFrame.
+   * e.g. union, class, etc. all call popFrame(). the current CompilerProgram needs to be aware of that, which this function is for.
+   */
+  popFrameImplicit(): void;
+  moveFrame(): void;
+  pushVariable(name: string, frame?: Frame): number;
+  pushTemplateParameter(name: string, withDefault?: boolean): number;
+  findVariable(name: string, frame?: Frame): {
+    frameOffset: number;
+    stackIndex: number;
+  };
+}
+declare class Cache {
+  resolver: ReflectionConfigCache;
+  sourceFiles: {
+    [fileName: string]: SourceFile$1;
+  };
+  globalSourceFiles?: SourceFile$1[];
+  /**
+   * Signals the cache to check if it needs to be cleared.
+   */
+  tick(): void;
+}
+/**
+ * Read the TypeScript AST and generate pack struct (instructions + pre-defined stack).
+ *
+ * This transformer extracts type and add the encoded (so its small and low overhead) at classes and functions as property.
+ *
+ * Deepkit/type can then extract and decode them on-demand.
+ */
+declare class ReflectionTransformer implements CustomTransformer {
+  protected context: TransformationContext;
+  protected cache: Cache;
+  sourceFile: SourceFile$1;
+  protected f: NodeFactory;
+  protected embedAssignType: boolean;
+  /**
+   * Types added to this map will get a type program directly under it.
+   * This is for types used in the very same file.
+   */
+  protected compileDeclarations: Map<ts.EnumDeclaration | ts.InterfaceDeclaration | ts.TypeAliasDeclaration, {
+    name: EntityName;
+    sourceFile: SourceFile$1;
+    compiled?: Statement[];
+  }>;
+  /**
+   * Types added to this map will get a type program at the top root level of the program.
+   * This is for imported types, which need to be inlined into the current file, as we do not emit type imports (TS will omit them).
+   */
+  protected embedDeclarations: Map<ts.Node, {
+    name: EntityName;
+    sourceFile?: SourceFile$1;
+  }>;
+  /**
+   * When a node was embedded or compiled (from the maps above), we store it here to know to not add it again.
+   */
+  protected compiledDeclarations: Set<ts.Node>;
+  protected addImports: {
+    importDeclaration: ImportDeclaration | JSDocImportTag;
+    identifier: Identifier;
+  }[];
+  protected additionalImports: Map<ts.ImportDeclaration | ts.JSDocImportTag, ts.Statement>;
+  protected nodeConverter: NodeConverter;
+  protected typeChecker?: TypeChecker;
+  protected resolver: Resolver;
+  protected host: CompilerHost;
+  protected overriddenHost: boolean;
+  protected overriddenConfigResolver?: ConfigResolver;
+  protected compilerOptions: CompilerOptions;
+  /**
+   * When a deep call expression was found a script-wide variable is necessary
+   * as temporary storage.
+   */
+  protected tempResultIdentifier?: Identifier;
+  protected parseConfigHost: ParseConfigHost;
+  protected intrinsicMetaDeclaration: TypeAliasDeclaration;
+  constructor(context: TransformationContext, cache?: Cache);
+  forHost(host: CompilerHost): this;
+  withReflection(config: ReflectionConfig): this;
+  transformBundle(node: Bundle): Bundle;
+  getTempResultIdentifier(): Identifier;
+  protected getConfigResolver(sourceFile: {
+    fileName: string;
+  }): ConfigResolver;
+  protected getReflectionConfig(sourceFile: {
+    fileName: string;
+  }): MatchResult;
+  protected isWithReflection(sourceFile: SourceFile$1 | undefined, node: Node & {
+    __deepkitConfig?: ReflectionConfig;
+  }): boolean;
+  transformSourceFile(sourceFile: SourceFile$1): SourceFile$1;
+  attachAdditionalStatements(statements: NodeArray<Statement> | Statement[]): Statement[];
+  protected getModuleType(): 'cjs' | 'esm';
+  protected getArrowFunctionΩPropertyAccessIdentifier(node: ArrowFunction): Identifier | undefined;
+  protected injectResetΩ<T extends FunctionDeclaration | FunctionExpression | MethodDeclaration | ConstructorDeclaration | ArrowFunction>(node: T): T;
+  protected createProgramVarFromNode(node: Node, name: EntityName, sourceFile?: SourceFile$1): Statement[];
+  protected extractPackStructOfExpression(node: Expression, program: CompilerProgram): void;
+  protected extractPackStructOfType(node: Node | Declaration | ClassDeclaration | ClassExpression, program: CompilerProgram): void;
+  protected knownClasses: {
+    [name: string]: ReflectionOp;
+  };
+  protected getGlobalLibs(): SourceFile$1[];
+  /**
+   * This is a custom resolver based on populated `locals` from the binder. It uses a custom resolution algorithm since
+   * we have no access to the binder/TypeChecker directly and instantiating a TypeChecker per file/transformer is incredible slow.
+   */
+  protected resolveDeclaration(typeName: EntityName): {
+    declaration: Node;
+    importDeclaration?: ImportDeclaration | JSDocImportTag;
+    typeOnly?: boolean;
+  } | void;
+  protected getDeclarationVariableName(typeName: EntityName): Identifier;
+  /**
+   * The semantic of isExcluded is different from checking if the fileName is part
+   * of reflection config option. isExcluded checks if the file should be excluded
+   * via the exclude option. mainly used to exclude globals and external libraries.
+   */
+  protected isExcluded(fileName: string): boolean;
+  protected extractPackStructOfTypeReference(type: TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram): void;
+  /**
+   * Returns the class declaration, function/arrow declaration, or block where type was used.
+   */
+  protected getTypeUser(type: Node): Node;
+  /**
+   * With this function we want to check if `type` is used in the signature itself from the parent of `declaration`.
+   * If so, we do not try to infer the type from runtime values.
+   *
+   * Examples where we do not infer from runtime, `type` being `T` and `declaration` being `<T>` (return false):
+   *
+   * ```typescript
+   * class User<T> {
+   *     config: T;
+   * }
+   *
+   * class User<T> {
+   *    constructor(public config: T) {}
+   * }
+   *
+   * function do<T>(item: T): void {}
+   * function do<T>(item: T): T {}
+   * ```
+   *
+   * Examples where we infer from runtime (return true):
+   *
+   * ```typescript
+   * function do<T>(item: T) {
+   *     return typeOf<T>; //<-- because of that
+   * }
+   *
+   * function do<T>(item: T) {
+   *     class A {
+   *         config: T; //<-- because of that
+   *     }
+   *     return A;
+   * }
+   *
+   * function do<T>(item: T) {
+   *     class A {
+   *         doIt() {
+   *             class B {
+   *                 config: T; //<-- because of that
+   *             }
+   *             return B;
+   *         }
+   *     }
+   *     return A;
+   * }
+   *
+   * function do<T>(item: T) {
+   *     class A {
+   *         doIt(): T { //<-- because of that
+   *         }
+   *     }
+   *     return A;
+   * }
+   * ```
+   */
+  protected needsToBeInferred(declaration: TypeParameterDeclaration, type: TypeReferenceNode | ExpressionWithTypeArguments): boolean;
+  protected resolveTypeOnlyImport(entityName: EntityName, program: CompilerProgram): void;
+  protected resolveTypeName(typeName: string, program: CompilerProgram): void;
+  protected resolveTypeParameter(declaration: TypeParameterDeclaration, type: TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram): void;
+  protected createAccessorForEntityName(e: QualifiedName): PropertyAccessExpression;
+  protected findDeclarationInFile(sourceFile: SourceFile$1 | ModuleDeclaration, declarationName: string): Declaration | undefined;
+  protected resolveImportSpecifier(_declarationName: string | ModuleExportName, importOrExport: ExportDeclaration | ImportDeclaration | JSDocImportTag, sourceFile: SourceFile$1): Declaration | undefined;
+  protected followExport(declarationName: string, statement: ExportDeclaration, sourceFile: SourceFile$1): Declaration | undefined;
+  protected getTypeOfType(type: Node | Declaration): Expression | undefined;
+  protected packOpsAndStack(program: CompilerProgram): ts.Expression;
+  /**
+   * Note: We have to duplicate the expressions as it can be that incoming expression are from another file and contain wrong pos/end properties,
+   * so the code generation is then broken when we simply reuse them. Wrong code like ``User.__type = [.toEqual({`` is then generated.
+   * This function is probably not complete, but we add new copies when required.
+   */
+  protected valueToExpression(value: undefined | PackExpression | PackExpression[]): Expression;
+  /**
+   * A class is decorated with type information by adding a static variable.
+   *
+   * class Model {
+   *     static __types = pack(ReflectionOp.string); //<-- encoded type information
+   *     title: string;
+   * }
+   */
+  protected decorateClass(sourceFile: SourceFile$1, node: ClassDeclaration | ClassExpression): Node;
+  /**
+   * const fn = function() {}
+   *
+   * => const fn = __assignType(function() {}, [34])
+   */
+  protected decorateFunctionExpression(expression: FunctionExpression): ts.FunctionExpression | ts.CallExpression;
+  /**
+   * function name() {}
+   *
+   * => function name() {}; name.__type = 34;
+   */
+  protected decorateFunctionDeclaration(declaration: FunctionDeclaration): ts.ExportAssignment | ts.FunctionDeclaration | ts.Statement[];
+  /**
+   * const fn = () => {}
+   * => const fn = __assignType(() => {}, [34])
+   */
+  protected decorateArrowFunction(expression: ArrowFunction): ts.ArrowFunction | ts.CallExpression;
+  /**
+   * Object.assign(fn, {__type: []}) is much slower than a custom implementation like
+   *
+   * assignType(fn, [])
+   *
+   * where we embed assignType() at the beginning of the type.
+   */
+  protected wrapWithAssignType(fn: Expression, type: Expression): ts.CallExpression;
+  /**
+   * Emit `{ __meta?: never & [name, value] }` — the runtime shape of `TypeAnnotation<name, value>`.
+   * Consumed later via `typeAnnotation.getOption(type, name)`.
+   */
+  protected emitTypeAnnotation(program: CompilerProgram, name: string, value: JSDocTagValue): void;
+  protected collectJSDocAnnotations(node: Node | undefined): {
+    description?: string;
+    annotations: {
+      name: string;
+      value: JSDocTagValue;
+    }[];
+  };
+  /**
+   * Run `emitType()` then intersect the result with TypeAnnotations derived from JSDoc/TSDoc.
+   * Also sets `ReflectionOp.description` when a description string is available (back-compat).
+   *
+   * @returns The resolved description string, if any.
+   */
+  protected withJSDocTypeAnnotations(program: CompilerProgram, node: Node | undefined, emitType: () => void, options?: {
+    applyDescriptionOp?: boolean;
+  }): string | undefined;
+  /**
+   * Checks if reflection was disabled/enabled in file via JSDoc attribute for a particular
+   * Node, e.g `@reflection no`. If nothing is found, "reflection" config option needs to be used.
+   */
+  protected getExplicitReflectionMode(sourceFile: SourceFile$1 | undefined, node: Node): boolean | undefined;
+}
+declare class DeclarationTransformer extends ReflectionTransformer {
+  protected addExports: {
+    identifier: string;
+  }[];
+  transformSourceFile(sourceFile: SourceFile$1): SourceFile$1;
+}
+declare const transformer: CustomTransformerFactory;
+declare const declarationTransformer: CustomTransformerFactory;
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/loader.d.ts
+declare class DeepkitLoader {
+  protected options: CompilerOptions;
+  protected host: ts.CompilerHost;
+  protected program: ts.Program;
+  protected printer: ts.Printer;
+  protected cache: Cache;
+  protected knownFiles: {
+    [path: string]: string;
+  };
+  protected sourceFiles: {
+    [path: string]: SourceFile;
+  };
+  constructor();
+  transform(source: string, path: string): string;
+}
+//#endregion
+//#region src/deepkit.d.ts
+/**
+ * Schema metadata options mirroring JSON Schema metadata keywords.
+ *
+ * @see https://deepkit.io/en/documentation/runtime-types/types#custom-type-annotations
+ */
+interface SchemaMetaOptions {
+  id?: string;
+  title?: string;
+  description?: string;
+  docs?: string;
+  alias?: string[];
+  tags?: string[];
+  deprecated?: boolean;
+  hidden?: boolean;
+  ignore?: boolean;
+  internal?: boolean;
+  runtime?: boolean;
+  examples?: (unknown | {
+    name?: string;
+    description?: string;
+    value: unknown;
+  })[];
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  contentEncoding?: string;
+  contentMediaType?: string;
+  contentSchema?: string;
+}
+/**
+ * Combined schema metadata annotation.
+ *
+ * @example
+ * ```ts
+ * type Username = string & SchemaMeta<{ title: "Username"; deprecated: true }>;
+ * ```
+ */
+type SchemaMeta<T extends SchemaMetaOptions> = TypeAnnotation<"schemaMeta", T>;
+/**
+ * Unique schema / property identifier.
+ *
+ * @example
+ * ```ts
+ * type UserId = string & Id<"user">;
+ * ```
+ */
+type Id<T extends string> = TypeAnnotation<"id", T>;
+/**
+ * Human-readable title.
+ *
+ * @example
+ * ```ts
+ * type Name = string & Title<"Display name">;
+ * ```
+ */
+type Title<T extends string> = TypeAnnotation<"title", T>;
+/**
+ * Human-readable description.
+ *
+ * @example
+ * ```ts
+ * type Bio = string & Description<"Short biography">;
+ * ```
+ */
+type Description<T extends string> = TypeAnnotation<"description", T>;
+/**
+ * External documentation URL.
+ *
+ * @example
+ * ```ts
+ * type Token = string & Docs<"https://example.com/docs/token">;
+ * ```
+ */
+type Docs<T extends string> = TypeAnnotation<"docs", T>;
+/**
+ * Alternate names for the field.
+ *
+ * @example
+ * ```ts
+ * type Email = string & Alias<["mail", "e-mail"]>;
+ * ```
+ */
+type Alias<T extends readonly string[]> = TypeAnnotation<"alias", T>;
+/**
+ * Categorization tags / groups.
+ *
+ * @example
+ * ```ts
+ * type Password = string & Tags<["credentials", "secret"]>;
+ * ```
+ */
+type Tags<T extends readonly string[]> = TypeAnnotation<"tags", T>;
+/**
+ * Marks the field as deprecated.
+ *
+ * @example
+ * ```ts
+ * type LegacyId = string & Deprecated;
+ * ```
+ */
+type Deprecated = TypeAnnotation<"deprecated">;
+/**
+ * Hides the field from documentation / UI surfaces.
+ *
+ * @example
+ * ```ts
+ * type Secret = string & Hidden;
+ * ```
+ */
+type Hidden = TypeAnnotation<"hidden">;
+/**
+ * Ignores the field during schema processing.
+ *
+ * @example
+ * ```ts
+ * type Scratch = string & Ignore;
+ * ```
+ */
+type Ignore = TypeAnnotation<"ignore">;
+/**
+ * Marks the field as internal.
+ *
+ * @example
+ * ```ts
+ * type InternalId = string & Internal;
+ * ```
+ */
+type Internal = TypeAnnotation<"internal">;
+/**
+ * Marks the field as populated only at runtime.
+ *
+ * @example
+ * ```ts
+ * type Computed = string & Runtime;
+ * ```
+ */
+type Runtime = TypeAnnotation<"runtime">;
+/**
+ * Example value shape for documentation.
+ */
+type SchemaExample = unknown | {
+  name?: string;
+  description?: string;
+  value: unknown;
+};
+/**
+ * Example values for documentation.
+ *
+ * @example
+ * ```ts
+ * type Status = string & Examples<[{ value: "active" }, { name: "Off", value: "inactive" }]>;
+ * ```
+ */
+type Examples<T extends readonly SchemaExample[]> = TypeAnnotation<"examples", T>;
+/**
+ * Marks the field as read-only.
+ *
+ * @example
+ * ```ts
+ * type CreatedAt = string & ReadOnly;
+ * ```
+ */
+type ReadOnly = TypeAnnotation<"readOnly">;
+/**
+ * Marks the field as write-only.
+ *
+ * @example
+ * ```ts
+ * type Password = string & WriteOnly;
+ * ```
+ */
+type WriteOnly = TypeAnnotation<"writeOnly">;
+/**
+ * Content encoding (e.g. `base64`).
+ *
+ * @example
+ * ```ts
+ * type Blob = string & ContentEncoding<"base64">;
+ * ```
+ */
+type ContentEncoding<T extends string> = TypeAnnotation<"contentEncoding", T>;
+/**
+ * Content media type (e.g. `application/json`).
+ *
+ * @example
+ * ```ts
+ * type Payload = string & ContentMediaType<"application/json">;
+ * ```
+ */
+type ContentMediaType<T extends string> = TypeAnnotation<"contentMediaType", T>;
+/**
+ * Content schema reference.
+ *
+ * @example
+ * ```ts
+ * type Body = string & ContentSchema<"https://example.com/schemas/body.json">;
+ * ```
+ */
+type ContentSchema<T extends string> = TypeAnnotation<"contentSchema", T>;
+//#endregion
+export { Alias, Cache, ContentEncoding, ContentMediaType, ContentSchema, DeclarationTransformer, DeepkitLoader, Deprecated, Description, Docs, Examples, Hidden, Id, Ignore, Internal, ReadOnly, ReflectionTransformer, Runtime, SchemaExample, SchemaMeta, SchemaMetaOptions, Tags, Title, WriteOnly, debugPackStruct, declarationTransformer, encodeOps, packSize, packSizeByte, transformer };
+//# sourceMappingURL=deepkit.d.mts.map

package/dist/deepkit.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepkit.d.mts","names":[],"sources":["../../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/ts-types.d.ts","../../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/reflection-ast.d.ts","../../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/resolver.d.ts","../../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/config.d.ts","../../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/compiler.d.ts","../../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=f3a07cea0d3f8fa5a7779d8e740cd5389fb06f7980aa96_4c91b7b6cb5be286e73f280b37a4b0c2/node_modules/@deepkit/type-compiler/dist/cjs/src/loader.d.ts","../src/deepkit.ts"],"x_google_ignoreList":[0,1,2,3,4,5],"mappings":""}

package/dist/deepkit.mjs

@@ -1,45 +1,3 @@
-export * from "@deepkit/type-compiler"
+import { a as debugPackStruct, c as packSize, i as ReflectionTransformer, l as packSizeByte, n as Cache, o as declarationTransformer, r as DeclarationTransformer, s as encodeOps, t as DeepkitLoader, u as transformer } from "./deepkit-h4w2bXJ2.mjs";
 
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-//#endregion
-//#region src/deepkit.ts
-var deepkit_exports = /* @__PURE__ */ __exportAll({});
-import * as import__deepkit_type_compiler from "@deepkit/type-compiler";
-__reExport(deepkit_exports, import__deepkit_type_compiler);
-
-//#endregion
-export { deepkit_exports as t };
-//# sourceMappingURL=deepkit.mjs.map
+export { Cache, DeclarationTransformer, DeepkitLoader, ReflectionTransformer, debugPackStruct, declarationTransformer, encodeOps, packSize, packSizeByte, transformer };