@rvoh/dream 0.29.1

package/dist/types/src/helpers/propertyNameFromFullyQualifiedModelName.d.ts

@@ -0,0 +1 @@
+export default function (str: string): string;

package/dist/types/src/helpers/protectAgainstPollutingAssignment.d.ts

@@ -0,0 +1 @@
+export default function protectAgainstPollutingAssignment(key: string): string;

package/dist/types/src/helpers/range.d.ts

@@ -0,0 +1,7 @@
+export default function range<T>(begin: T | null, end?: T | null, excludeEnd?: boolean): Range<T>;
+export declare class Range<T> {
+    readonly begin: T | null;
+    readonly end: T | null;
+    readonly excludeEnd: boolean;
+    constructor(begin: T | null, end?: T | null, excludeEnd?: boolean);
+}

package/dist/types/src/helpers/round.d.ts

@@ -0,0 +1,2 @@
+export default function round(num: number, precision?: RoundingPrecision): number;
+export type RoundingPrecision = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

package/dist/types/src/helpers/serializerNameFromFullyQualifiedModelName.d.ts

@@ -0,0 +1 @@
+export default function (fullyQualifiedModelName: string, serializerType?: 'default' | 'summary'): string;

package/dist/types/src/helpers/snakeify.d.ts

@@ -0,0 +1,3 @@
+import { Snakeified } from './stringCasing.js';
+export default function snakeify<const T, RT extends Snakeified<T>>(target: T): RT;
+export declare function snakeifyString(str: string): string;

package/dist/types/src/helpers/sortBy.d.ts

@@ -0,0 +1,8 @@
+import { IdType } from '../dream/types.js';
+export default function sortBy<T>(array: T[], valueToCompare: (value: T) => number | string | bigint | IdType): T[];
+export declare class UnsupportedValueFromComparisonFunction extends Error {
+    private aPrime;
+    private bPrime;
+    constructor(aPrime: any, bPrime: any);
+    get message(): string;
+}

package/dist/types/src/helpers/sqlAttributes.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../Dream.js';
+export default function sqlAttributes(dream: Dream): {
+    [key: string]: any;
+};

package/dist/types/src/helpers/sspawn.d.ts

@@ -0,0 +1,2 @@
+export default function sspawn(command: string, opts?: any): Promise<unknown>;
+export declare function ssspawn(command: string, opts?: any): import("child_process").ChildProcessWithoutNullStreams;

package/dist/types/src/helpers/standardizeFullyQualifiedModelName.d.ts

@@ -0,0 +1 @@
+export default function (str: string): string;

package/dist/types/src/helpers/stringCasing.d.ts

@@ -0,0 +1,28 @@
+import { ReadonlyHead, NotReadonlyHead, ReadonlyTail, NotReadonlyTail } from './typeutils.js';
+type RecursivelyStringCaseObjectKeysInTuple<T extends any[], StringCaseType extends StringCasingOptions> = T['length'] extends 0 ? [] : [
+    RecursiveStringCase<NotReadonlyHead<T>, StringCaseType>,
+    ...RecursivelyStringCaseObjectKeysInTuple<NotReadonlyTail<T>, StringCaseType>
+];
+type ReadOnlyRecursivelyStringCaseObjectKeysInTuple<T extends readonly any[], StringCaseType extends StringCasingOptions> = T['length'] extends 0 ? readonly [] : readonly [
+    RecursiveStringCase<ReadonlyHead<T>, StringCaseType>,
+    ...ReadOnlyRecursivelyStringCaseObjectKeysInTuple<ReadonlyTail<T>, StringCaseType>
+];
+type RecursiveStringCase<T, StringCaseType extends StringCasingOptions, RT = T extends string ? T : T extends readonly string[] | string[] ? T : T extends readonly any[] ? ReadOnlyRecursivelyStringCaseObjectKeysInTuple<T, StringCaseType> : T extends any[] ? RecursivelyStringCaseObjectKeysInTuple<T, StringCaseType> : T extends object ? {
+    -readonly [key in keyof T as key extends string ? StringCaseString<key, StringCaseType> : key]: RecursiveStringCase<T[key], StringCaseType>;
+} : T> = RT;
+type StringCasingOptions = 'Camelize' | 'Snakeify' | 'Hyphenize' | 'Pascalize';
+export type Camelized<T> = StringCase<'Camelize', T>;
+export type Snakeified<T> = StringCase<'Snakeify', T>;
+export type Hyphenized<T> = StringCase<'Hyphenize', T>;
+export type Pascalized<T> = StringCase<'Pascalize', T>;
+type StringCase<StringCaseType extends StringCasingOptions, T, RT = T extends string ? StringCaseString<T, StringCaseType> : RecursiveStringCase<T, StringCaseType>> = RT;
+type StringCaseString<T extends string, StringCaseType extends StringCasingOptions> = StringCaseType extends 'Camelize' ? CamelizeString<T> : StringCaseType extends 'Snakeify' ? SnakeifyString<T> : StringCaseType extends 'Hyphenize' ? HyphenizeString<T> : StringCaseType extends 'Pascalize' ? PascalizeString<T> : never;
+type InnerCamelizeString<T extends string> = T extends `${infer A}_${infer B}` ? `${A}${InnerCamelizeString<Capitalize<B>>}` : T extends `${infer A}-${infer B}` ? `${A}${InnerCamelizeString<Capitalize<B>>}` : T extends `${infer A} ${infer B}` ? `${A}${InnerCamelizeString<Capitalize<B>>}` : T;
+type Punctuation = ',' | '.' | '/' | '<' | '>' | '?' | ';' | "'" | ':' | '"' | '[' | ']' | '{' | '}' | '\\' | '|' | '!' | '@' | '#' | '$' | '%' | '^' | '&' | '*' | '(' | ')' | '`';
+type InnerCapitalsToCharacterDelimiter<S extends string, Delimiter extends '-' | '_'> = S extends `${infer P extends Punctuation}${infer T}${infer U}` ? `${P}${Lowercase<T>}${InnerCapitalsToCharacterDelimiter<U, Delimiter>}` : S extends `${infer T}${infer U}` ? T extends Capitalize<T> ? T extends Lowercase<T> ? `${T}${InnerCapitalsToCharacterDelimiter<U, Delimiter>}` : `${Delimiter}${Lowercase<T>}${InnerCapitalsToCharacterDelimiter<U, Delimiter>}` : `${T}${InnerCapitalsToCharacterDelimiter<U, Delimiter>}` : S;
+type SnakeifyString<S extends string> = InnerCapitalsToCharacterDelimiter<CamelizeString<S>, '_'>;
+type HyphenizeString<S extends string> = InnerCapitalsToCharacterDelimiter<CamelizeString<S>, '-'>;
+type PascalizeString<S extends string> = Capitalize<InnerCamelizeString<S>>;
+type CamelizeString<S extends string> = Uncapitalize<InnerCamelizeString<S>>;
+export default function stringCase(target: any, stringCaser: (x: string) => string): any;
+export {};

package/dist/types/src/helpers/typechecks.d.ts

@@ -0,0 +1,2 @@
+export declare function isString(x: any): boolean;
+export declare function isObject(x: any): boolean;

package/dist/types/src/helpers/typeutils.d.ts

@@ -0,0 +1,115 @@
+export type Inc<T extends number> = T extends keyof IncTable ? IncTable[T] : never;
+type IncTable = {
+    0: 1;
+    1: 2;
+    2: 3;
+    3: 4;
+    4: 5;
+    5: 6;
+    6: 7;
+    7: 8;
+    8: 9;
+    9: 10;
+    10: 11;
+    11: 12;
+    12: 13;
+    13: 14;
+    14: 15;
+    15: 16;
+    16: 17;
+    17: 18;
+    18: 19;
+    19: 20;
+    20: 21;
+    21: 22;
+    22: 23;
+    23: 24;
+    24: 25;
+    25: 26;
+    26: 27;
+    27: 28;
+    28: 29;
+    29: 30;
+    30: 31;
+    31: 32;
+};
+export type Decrement<T extends number> = T extends keyof DecrementTable ? DecrementTable[T] : never;
+type DecrementTable = {
+    0: -1;
+    1: 0;
+    2: 1;
+    3: 2;
+    4: 3;
+    5: 4;
+    6: 5;
+    7: 6;
+    8: 7;
+    9: 8;
+    10: 9;
+    11: 10;
+    12: 11;
+    13: 12;
+    14: 13;
+    15: 15;
+    16: 15;
+    17: 16;
+    18: 17;
+    19: 18;
+    20: 19;
+    21: 20;
+    22: 21;
+    23: 22;
+    24: 23;
+    25: 24;
+    26: 25;
+    27: 26;
+    28: 27;
+    29: 28;
+    30: 29;
+    31: 30;
+};
+/**
+ *
+ *  Given two interfaces that define the same attributes, but with different types for the values,
+ *  create a new type that allows all of the types allowed for a particular key by either of the
+ * joined types.
+ *
+ * @example
+ * ```
+ * type A = {
+ *     a: string
+ *     c: 'hello'
+ * }
+ *
+ * type B = {
+ *     b: number
+ *     c: 'world'
+ * }
+ *
+ * type Combined = MergeUnionOfRecordTypes<A | B>
+ *
+ * // Combined is now equivalent to type {
+ * //     a: string,
+ * //     b: number,
+ * //     c: 'hello' | 'world',
+ * // }
+ *
+ * ```
+ * From https://stackoverflow.com/a/72375765/349332
+ */
+export type MergeUnionOfRecordTypes<U extends Record<string, unknown>> = {
+    [K in U extends unknown ? keyof U : never]: U extends unknown ? (K extends keyof U ? U[K] : never) : never;
+};
+export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export type FilterInterface<Source, Condition> = Pick<Source, {
+    [K in keyof Source]: Source[K] extends Condition ? K : never;
+}[keyof Source]>;
+export type RejectInterface<Source, Condition> = Pick<Source, {
+    [K in keyof Source]: Source[K] extends Condition ? never : K;
+}[keyof Source]>;
+export type ReadonlyTail<T extends readonly any[]> = T extends readonly [any, ...infer Tail] ? Tail : readonly [];
+export type NotReadonlyTail<T extends any[]> = T extends [any, ...infer Tail] ? Tail : [];
+export type ReadonlyHead<T extends readonly any[]> = T extends readonly [infer Head, ...any] ? Head : undefined;
+export type NotReadonlyHead<T extends readonly any[]> = T extends [infer Head, ...any] ? Head : undefined;
+export type FindInterfaceWithValue<T, Key, Value> = T extends Readonly<[infer First, ...infer Rest]> ? Key extends keyof First ? First[Key] extends never ? Value extends never ? First : FindInterfaceWithValue<Rest, Key, Value> : First[Key] extends Value ? First : FindInterfaceWithValue<Rest, Key, Value> : FindInterfaceWithValue<Rest, Key, Value> : never;
+export {};

package/dist/types/src/helpers/uncapitalize.d.ts

@@ -0,0 +1 @@
+export default function uncapitalize(str: string): string;

package/dist/types/src/helpers/uniq.d.ts

@@ -0,0 +1 @@
+export default function uniq<T>(arr: T[], toKey?: ((a: T) => string) | undefined): T[];

package/dist/types/src/index.d.ts

@@ -0,0 +1,78 @@
+export { default as DreamBin } from './bin/index.js';
+export { default as DreamCLI } from './cli/index.js';
+export { closeAllDbConnections, dreamDbConnections } from './db/DreamDbConnection.js';
+export { pgErrorType } from './db/errors.js';
+export { default as db } from './db/index.js';
+export { default as DreamMigrationHelpers } from './db/migration-helpers/DreamMigrationHelpers.js';
+export { default as validateColumn } from './db/validators/validateColumn.js';
+export { default as validateTable } from './db/validators/validateTable.js';
+export { type WhereStatementForDream, type WhereStatementForDreamClass, } from './decorators/associations/shared.js';
+export { type DecoratorContext } from './decorators/DecoratorContextType.js';
+export { default as Decorators } from './decorators/Decorators.js';
+export { default as AfterCreate } from './decorators/hooks/AfterCreate.js';
+export { default as AfterCreateCommit } from './decorators/hooks/AfterCreateCommit.js';
+export { default as AfterDestroy } from './decorators/hooks/AfterDestroy.js';
+export { default as AfterDestroyCommit } from './decorators/hooks/AfterDestroyCommit.js';
+export { default as AfterSave } from './decorators/hooks/AfterSave.js';
+export { default as AfterSaveCommit } from './decorators/hooks/AfterSaveCommit.js';
+export { default as AfterUpdate } from './decorators/hooks/AfterUpdate.js';
+export { default as AfterUpdateCommit } from './decorators/hooks/AfterUpdateCommit.js';
+export { default as BeforeCreate } from './decorators/hooks/BeforeCreate.js';
+export { default as BeforeDestroy } from './decorators/hooks/BeforeDestroy.js';
+export { default as BeforeSave } from './decorators/hooks/BeforeSave.js';
+export { default as BeforeUpdate } from './decorators/hooks/BeforeUpdate.js';
+export { default as ReplicaSafe } from './decorators/ReplicaSafe.js';
+export { default as Scope } from './decorators/Scope.js';
+export { default as SoftDelete } from './decorators/SoftDelete.js';
+export { default as Sortable } from './decorators/sortable/Sortable.js';
+export { default as STI } from './decorators/STI.js';
+export { type ValidationType } from './decorators/validations/shared.js';
+export { default as Validate } from './decorators/validations/Validate.js';
+export { default as Validates } from './decorators/validations/Validates.js';
+export { default as Virtual } from './decorators/Virtual.js';
+export { default as DreamImporter } from './dream-application/helpers/DreamImporter.js';
+export { default as lookupClassByGlobalName } from './dream-application/helpers/lookupClassByGlobalName.js';
+export { default as DreamApplication, type DreamApplicationInitOptions, type DreamApplicationOpts, type DreamLogger, type DreamLogLevel, } from './dream-application/index.js';
+export { default as Dream } from './Dream.js';
+export { default as DreamTransaction } from './dream/DreamTransaction.js';
+export { default as Query } from './dream/Query.js';
+export { DreamConst, type DreamAssociationMetadata, type DreamAttributes, type DreamClassColumn, type DreamColumn, type DreamColumnNames, type DreamOrViewModelSerializerKey, type DreamParamSafeAttributes, type DreamParamSafeColumnNames, type DreamSerializerKey, type DreamSerializers, type DreamTableSchema, type DreamVirtualColumns, type IdType, type PrimaryKeyType, type primaryKeyTypes, type SerializableClassOrSerializerCallback, type SerializableDreamClassOrViewModelClass, type SerializableDreamOrViewModel, type Timestamp, type TRIGRAM_OPERATORS, type UpdateableAssociationProperties, type UpdateableProperties, type ViewModelSerializerKey, } from './dream/types.js';
+export { default as Encrypt, type EncryptAlgorithm, type EncryptOptions } from './encrypt/index.js';
+export { default as NonLoadedAssociation } from './errors/associations/NonLoadedAssociation.js';
+export { default as CreateOrFindByFailedToCreateAndFind } from './errors/CreateOrFindByFailedToCreateAndFind.js';
+export { default as GlobalNameNotSet } from './errors/dream-application/GlobalNameNotSet.js';
+export { default as RecordNotFound } from './errors/RecordNotFound.js';
+export { default as ValidationError } from './errors/ValidationError.js';
+export { default as Benchmark } from './helpers/benchmark.js';
+export { default as CalendarDate } from './helpers/CalendarDate.js';
+export { default as camelize } from './helpers/camelize.js';
+export { default as capitalize } from './helpers/capitalize.js';
+export { default as generateDream } from './helpers/cli/generateDream.js';
+export { default as compact } from './helpers/compact.js';
+export { default as debug } from './helpers/debug.js';
+export { default as Env } from './helpers/Env.js';
+export { default as globalClassNameFromFullyQualifiedModelName } from './helpers/globalClassNameFromFullyQualifiedModelName.js';
+export { default as hyphenize } from './helpers/hyphenize.js';
+export { inferSerializerFromDreamClassOrViewModelClass, default as inferSerializerFromDreamOrViewModel, } from './helpers/inferSerializerFromDreamOrViewModel.js';
+export { default as isEmpty } from './helpers/isEmpty.js';
+export { default as loadRepl } from './helpers/loadRepl.js';
+export { default as pascalize } from './helpers/pascalize.js';
+export { default as dreamPath } from './helpers/path/dreamPath.js';
+export { default as relativeDreamPath } from './helpers/path/relativeDreamPath.js';
+export { default as sharedPathPrefix } from './helpers/path/sharedPathPrefix.js';
+export { Range, default as range } from './helpers/range.js';
+export { default as round, type RoundingPrecision } from './helpers/round.js';
+export { default as serializerNameFromFullyQualifiedModelName } from './helpers/serializerNameFromFullyQualifiedModelName.js';
+export { default as snakeify } from './helpers/snakeify.js';
+export { default as sortBy } from './helpers/sortBy.js';
+export { default as standardizeFullyQualifiedModelName } from './helpers/standardizeFullyQualifiedModelName.js';
+export { type Camelized, type Hyphenized, type Pascalized, type Snakeified } from './helpers/stringCasing.js';
+export { default as uncapitalize } from './helpers/uncapitalize.js';
+export { default as uniq } from './helpers/uniq.js';
+export { openapiPrimitiveTypes, openapiShorthandPrimitiveTypes, type CommonOpenapiSchemaObjectFields, type OpenapiAllTypes, type OpenapiFormats, type OpenapiNumberFormats, type OpenapiPrimitiveTypes, type OpenapiSchemaArray, type OpenapiSchemaArrayShorthand, type OpenapiSchemaBase, type OpenapiSchemaBody, type OpenapiSchemaBodyShorthand, type OpenapiSchemaCommonFields, type OpenapiSchemaExpressionAllOf, type OpenapiSchemaExpressionAnyOf, type OpenapiSchemaExpressionOneOf, type OpenapiSchemaExpressionRef, type OpenapiSchemaExpressionRefSchemaShorthand, type OpenapiSchemaInteger, type OpenapiSchemaNull, type OpenapiSchemaNumber, type OpenapiSchemaObject, type OpenapiSchemaObjectAllOf, type OpenapiSchemaObjectAllOfShorthand, type OpenapiSchemaObjectAnyOf, type OpenapiSchemaObjectAnyOfShorthand, type OpenapiSchemaObjectBase, type OpenapiSchemaObjectBaseShorthand, type OpenapiSchemaObjectOneOf, type OpenapiSchemaObjectOneOfShorthand, type OpenapiSchemaObjectShorthand, type OpenapiSchemaPartialSegment, type OpenapiSchemaPrimitiveGeneric, type OpenapiSchemaProperties, type OpenapiSchemaPropertiesShorthand, type OpenapiSchemaShorthandExpressionAllOf, type OpenapiSchemaShorthandExpressionAnyOf, type OpenapiSchemaShorthandExpressionOneOf, type OpenapiSchemaShorthandExpressionSerializableRef, type OpenapiSchemaShorthandExpressionSerializerRef, type OpenapiSchemaShorthandPrimitiveGeneric, type OpenapiSchemaString, type OpenapiShorthandAllTypes, type OpenapiShorthandPrimitiveTypes, type OpenapiTypeField, type OpenapiTypeFieldObject, } from './openapi/types.js';
+export { default as ops } from './ops/index.js';
+export { default as RendersMany } from './serializer/decorators/associations/RendersMany.js';
+export { default as RendersOne } from './serializer/decorators/associations/RendersOne.js';
+export { type DreamSerializerAssociationStatement } from './serializer/decorators/associations/shared.js';
+export { default as Attribute, type AttributeStatement, type SerializableTypes, } from './serializer/decorators/attribute.js';
+export { default as DreamSerializer } from './serializer/index.js';

package/dist/types/src/openapi/types.d.ts

@@ -0,0 +1,139 @@
+import { SerializableDreamClassOrViewModelClass } from '../dream/types.js';
+import DreamSerializer from '../serializer/index.js';
+export type OpenapiSchemaBody = OpenapiSchemaBase | OpenapiSchemaPrimitiveGeneric | OpenapiSchemaExpressionAnyOf | OpenapiSchemaExpressionOneOf | OpenapiSchemaExpressionAllOf | OpenapiSchemaObject | OpenapiSchemaArray;
+export type OpenapiSchemaBodyShorthand = OpenapiSchemaBase | OpenapiSchemaShorthandPrimitiveGeneric | OpenapiSchemaShorthandExpressionAnyOf | OpenapiSchemaShorthandExpressionOneOf | OpenapiSchemaShorthandExpressionAllOf | OpenapiSchemaObjectShorthand | OpenapiSchemaArrayShorthand | OpenapiSchemaNull | OpenapiSchemaExpressionRefSchemaShorthand | OpenapiSchemaShorthandExpressionSerializerRef | OpenapiSchemaShorthandExpressionSerializableRef;
+export type OpenapiSchemaBase = OpenapiSchemaString | OpenapiSchemaInteger | OpenapiSchemaNumber | OpenapiSchemaNull | OpenapiSchemaExpressionRef;
+export type OpenapiSchemaShorthandExpressionAnyOf = {
+    anyOf: (OpenapiSchemaBodyShorthand | OpenapiSchemaPartialSegment)[];
+};
+export type OpenapiSchemaShorthandExpressionOneOf = {
+    oneOf: (OpenapiSchemaBodyShorthand | OpenapiSchemaPartialSegment)[];
+};
+export type OpenapiSchemaShorthandExpressionAllOf = {
+    allOf: (OpenapiSchemaBodyShorthand | OpenapiSchemaPartialSegment)[];
+};
+export type OpenapiSchemaPartialSegment = {
+    nullable?: boolean;
+};
+export type OpenapiSchemaShorthandExpressionSerializerRef = {
+    $serializer: typeof DreamSerializer;
+    many?: boolean;
+    nullable?: boolean;
+};
+export type OpenapiSchemaShorthandExpressionSerializableRef = {
+    $serializable: SerializableDreamClassOrViewModelClass;
+    many?: boolean;
+    nullable?: boolean;
+    key?: string;
+};
+export type OpenapiSchemaExpressionRef = {
+    $ref: string;
+};
+export type OpenapiSchemaExpressionRefSchemaShorthand = {
+    $schema: string;
+};
+export type OpenapiSchemaExpressionAllOf = {
+    allOf: (OpenapiSchemaBody | OpenapiSchemaPartialSegment)[];
+};
+export type OpenapiSchemaExpressionAnyOf = {
+    anyOf: (OpenapiSchemaBody | OpenapiSchemaPartialSegment)[];
+};
+export type OpenapiSchemaExpressionOneOf = {
+    oneOf: (OpenapiSchemaBody | OpenapiSchemaPartialSegment)[];
+};
+export type OpenapiSchemaCommonFields<T> = T & {
+    nullable?: boolean;
+    description?: string;
+    summary?: string;
+};
+export type OpenapiSchemaString = OpenapiSchemaCommonFields<{
+    type: 'string';
+    enum?: string[] | Readonly<string[]>;
+    format?: string;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+}>;
+export type OpenapiSchemaInteger = OpenapiSchemaCommonFields<{
+    type: 'integer';
+    minimum?: number;
+    maximum?: number;
+}>;
+export type OpenapiSchemaNumber = OpenapiSchemaCommonFields<{
+    type: 'number';
+    format?: OpenapiNumberFormats;
+    multipleOf?: number;
+    minimum?: number;
+    maximum?: number;
+}>;
+export type OpenapiSchemaNull = {
+    type: 'null';
+};
+export type OpenapiNumberFormats = 'decimal' | 'double';
+export type OpenapiSchemaObject = OpenapiSchemaObjectBase | OpenapiSchemaObjectOneOf | OpenapiSchemaObjectAnyOf | OpenapiSchemaObjectAllOf;
+export type OpenapiSchemaObjectBase = CommonOpenapiSchemaObjectFields<{
+    minProperties?: number;
+    maxProperties?: number;
+    properties?: OpenapiSchemaProperties | OpenapiSchemaExpressionOneOf | OpenapiSchemaExpressionAnyOf | OpenapiSchemaExpressionAllOf;
+    additionalProperties?: OpenapiSchemaObject | OpenapiSchemaExpressionOneOf | OpenapiSchemaExpressionAnyOf | OpenapiSchemaExpressionAllOf;
+}>;
+export type OpenapiSchemaObjectOneOf = CommonOpenapiSchemaObjectFields<{
+    oneOf?: OpenapiSchemaBody[];
+}>;
+export type OpenapiSchemaObjectAnyOf = CommonOpenapiSchemaObjectFields<{
+    anyOf?: OpenapiSchemaBody[];
+}>;
+export type OpenapiSchemaObjectAllOf = CommonOpenapiSchemaObjectFields<{
+    allOf?: OpenapiSchemaBody[];
+}>;
+export type OpenapiSchemaObjectShorthand = OpenapiSchemaObjectBaseShorthand | OpenapiSchemaObjectOneOfShorthand | OpenapiSchemaObjectAnyOfShorthand | OpenapiSchemaObjectAllOfShorthand;
+export type OpenapiSchemaObjectBaseShorthand = CommonOpenapiSchemaObjectFields<{
+    minProperties?: number;
+    maxProperties?: number;
+    properties?: OpenapiSchemaPropertiesShorthand | OpenapiSchemaShorthandExpressionOneOf | OpenapiSchemaShorthandExpressionAnyOf | OpenapiSchemaShorthandExpressionAllOf | OpenapiSchemaShorthandExpressionSerializerRef | OpenapiSchemaShorthandExpressionSerializableRef;
+    additionalProperties?: OpenapiShorthandPrimitiveTypes | OpenapiSchemaBodyShorthand | OpenapiSchemaShorthandExpressionOneOf | OpenapiSchemaShorthandExpressionAnyOf | OpenapiSchemaShorthandExpressionAllOf | OpenapiSchemaShorthandExpressionSerializerRef | OpenapiSchemaShorthandExpressionSerializableRef;
+}>;
+export type OpenapiSchemaObjectOneOfShorthand = CommonOpenapiSchemaObjectFields<{
+    oneOf?: OpenapiSchemaBodyShorthand[];
+}>;
+export type OpenapiSchemaObjectAnyOfShorthand = CommonOpenapiSchemaObjectFields<{
+    anyOf?: OpenapiSchemaBodyShorthand[];
+}>;
+export type OpenapiSchemaObjectAllOfShorthand = CommonOpenapiSchemaObjectFields<{
+    allOf?: OpenapiSchemaBodyShorthand[];
+}>;
+export type CommonOpenapiSchemaObjectFields<T> = OpenapiSchemaCommonFields<T & {
+    type: 'object';
+    required?: string[];
+}>;
+export type OpenapiSchemaArray = OpenapiSchemaCommonFields<{
+    type: 'array';
+    items: OpenapiSchemaBody | OpenapiSchemaExpressionAllOf | OpenapiSchemaExpressionAnyOf | OpenapiSchemaExpressionOneOf;
+}>;
+export type OpenapiSchemaArrayShorthand = OpenapiSchemaCommonFields<{
+    type: 'array';
+    items: OpenapiSchemaBodyShorthand | OpenapiSchemaShorthandExpressionAllOf | OpenapiSchemaShorthandExpressionAnyOf | OpenapiSchemaShorthandExpressionOneOf | OpenapiSchemaShorthandExpressionSerializerRef | OpenapiSchemaShorthandExpressionSerializableRef;
+}>;
+export interface OpenapiSchemaProperties {
+    [key: string]: OpenapiSchemaBody;
+}
+export type OpenapiSchemaPrimitiveGeneric = OpenapiSchemaCommonFields<{
+    type: OpenapiPrimitiveTypes;
+}>;
+export type OpenapiSchemaShorthandPrimitiveGeneric = OpenapiSchemaCommonFields<{
+    type: OpenapiShorthandPrimitiveTypes;
+}>;
+export interface OpenapiSchemaPropertiesShorthand {
+    [key: string]: OpenapiSchemaBodyShorthand | OpenapiShorthandPrimitiveTypes;
+}
+export declare const openapiPrimitiveTypes: readonly ["string", "boolean", "number", "date", "date-time", "double", "integer", "null"];
+export declare const openapiShorthandPrimitiveTypes: readonly ["string", "boolean", "number", "date", "date-time", "double", "integer", "null", "decimal", "string[]", "boolean[]", "number[]", "date[]", "date-time[]", "decimal[]", "double[]", "integer[]", "json"];
+export type OpenapiPrimitiveTypes = (typeof openapiPrimitiveTypes)[number];
+export type OpenapiShorthandPrimitiveTypes = (typeof openapiShorthandPrimitiveTypes)[number];
+export type OpenapiAllTypes = OpenapiPrimitiveTypes | 'object' | 'array';
+export type OpenapiShorthandAllTypes = OpenapiShorthandPrimitiveTypes | 'object' | 'array';
+export type OpenapiTypeField = OpenapiPrimitiveTypes | OpenapiTypeFieldObject;
+export interface OpenapiTypeFieldObject {
+    [key: string]: OpenapiPrimitiveTypes | OpenapiTypeFieldObject;
+}
+export type OpenapiFormats = 'application/json';

package/dist/types/src/ops/curried-ops-statement.d.ts

@@ -0,0 +1,7 @@
+import Dream from '../Dream.js';
+import OpsStatement from './ops-statement.js';
+export default class CurriedOpsStatement<T extends typeof Dream, DB extends InstanceType<T>['DB'], FN extends keyof DB[InstanceType<T>['table']] & string, FinalType> {
+    factoryFn: (dreamClass: T, fieldName: FN) => OpsStatement<any, FinalType>;
+    constructor(factoryFn: (dreamClass: T, fieldName: FN) => OpsStatement<any, FinalType>);
+    toOpsStatement(dreamClass: T, fieldName: FN): OpsStatement<any, FinalType, import("./ops-statement.js").ExtraSimilarityArgs | undefined>;
+}

package/dist/types/src/ops/index.d.ts

@@ -0,0 +1,49 @@
+import { ComparisonOperatorExpression as KyselyComparisonOperatorExpression } from 'kysely';
+import { TrigramOperator } from '../dream/types.js';
+import CurriedOpsStatement from './curried-ops-statement.js';
+import OpsStatement from './ops-statement.js';
+type ArrayOperatorType = 'in' | 'not in';
+declare const ops: {
+    expression: <const T, const Operator extends KyselyComparisonOperatorExpression | TrigramOperator, const ComputedT extends Operator extends ArrayOperatorType ? (T & Readonly<unknown[]>)[number] : T>(operator: Operator, value: T) => OpsStatement<Operator, ComputedT, any>;
+    in: <const T extends unknown[]>(arr: T) => OpsStatement<"in", T[number], undefined>;
+    any: <const AnyT>(value: AnyT) => CurriedOpsStatement<any, any, any, AnyT>;
+    like: (like: string) => OpsStatement<"like", string, undefined>;
+    ilike: (ilike: string) => OpsStatement<"ilike", string, undefined>;
+    match: (match: string, { caseInsensitive }?: {
+        caseInsensitive?: boolean;
+    }) => OpsStatement<"~" | "~*", string, undefined>;
+    equal: <const T>(equal: T) => OpsStatement<"=", T, undefined>;
+    lessThan: <const T>(lessThan: T) => OpsStatement<"<", T, undefined>;
+    lessThanOrEqualTo: <const T>(lessThanOrEqualTo: T) => OpsStatement<"<=", T, undefined>;
+    greaterThan: <const T>(greaterThan: T) => OpsStatement<">", T, undefined>;
+    greaterThanOrEqualTo: <const T>(greaterThanOrEqualTo: T) => OpsStatement<">=", T, undefined>;
+    similarity: (similarity: string, { score }?: {
+        score?: number;
+    }) => OpsStatement<"%", string, {
+        score: number;
+    }>;
+    wordSimilarity: (similarity: string, { score }?: {
+        score?: number;
+    }) => OpsStatement<"<%", string, {
+        score: number;
+    }>;
+    strictWordSimilarity: (similarity: string, { score }?: {
+        score?: number;
+    }) => OpsStatement<"<<%", string, {
+        score: number;
+    }>;
+    not: {
+        in: <const T extends unknown[]>(arr: T) => OpsStatement<"not in", T[number], undefined>;
+        like: (like: string) => OpsStatement<"not like", string, undefined>;
+        ilike: (ilike: string) => OpsStatement<"not ilike", string, undefined>;
+        match: (match: string, { caseInsensitive }?: {
+            caseInsensitive?: boolean;
+        }) => OpsStatement<"!~" | "!~*", string, undefined>;
+        equal: <const T>(equal: T) => OpsStatement<"!=", T, undefined>;
+        lessThan: <const T>(lessThan: T) => OpsStatement<">=", T, undefined>;
+        lessThanOrEqualTo: <const T>(lessThanOrEqualTo: T) => OpsStatement<">", T, undefined>;
+        greaterThan: <const T>(greaterThan: T) => OpsStatement<"<=", T, undefined>;
+        greaterThanOrEqualTo: <const T>(greaterThanOrEqualTo: T) => OpsStatement<"<", T, undefined>;
+    };
+};
+export default ops;

package/dist/types/src/ops/ops-statement.d.ts

@@ -0,0 +1,14 @@
+import { ComparisonOperatorExpression as KyselyComparisonOperatorExpression } from 'kysely';
+import { TrigramOperator } from '../dream/types.js';
+export interface ExtraSimilarityArgs {
+    score?: number;
+}
+export default class OpsStatement<COE extends KyselyComparisonOperatorExpression | TrigramOperator, ValType, ExtraArgs = COE extends '%' | '<%' | '<<%' ? ExtraSimilarityArgs | undefined : undefined> {
+    readonly operator: COE;
+    readonly value: ValType;
+    readonly extraArgs?: ExtraArgs | undefined;
+    constructor(operator: COE, value: ValType, extraArgs?: ExtraArgs | undefined);
+    get isOpsStatement(): boolean;
+    get shouldBypassWhereStatement(): boolean;
+    get minTrigramScore(): number | null | undefined;
+}

package/dist/types/src/serializer/decorators/associations/RendersMany.d.ts

@@ -0,0 +1,42 @@
+import { SerializableClassOrClasses } from '../../../dream/types.js';
+import { RendersOneOrManyOpts } from './shared.js';
+/**
+ * Establishes a One to Many relationship between
+ * the base serializer and the child serializer
+ *
+ * This relationship is similar to a RendersOne relationship,
+ * except that it will an array of serialized records. It is generally
+ * used to correspond with a HasMany association
+ * on the models being driven through the serializer.
+ *
+ * If no argument is provided to RendersMany, it will infer the serializer
+ * by looking to the default serializer of the model
+ *
+ * ```ts
+ * class User extends ApplicationModel {
+ *   @Deco.HasOne('Settings')
+ *   public settings: Settings
+ * }
+ *
+ * class Post extends ApplicationModel {
+ *   @Deco.BelongsTo('User')
+ *   public user: User
+ * }
+ *
+ * class UserSerializer {
+ *   @RendersMany()
+ *   public posts: Post[]
+ * }
+ * ```
+ *
+ * An explicit serializer can also be provided:
+ *
+ * ```ts
+ * class UserSerializer {
+ *   @RendersMany(() => PostSummarySerializer)
+ *   public posts: Post[]
+ * }
+ * ```
+ */
+export default function RendersMany(serializableClassOrClasses?: SerializableClassOrClasses | RendersManyOpts | null, opts?: RendersManyOpts): any;
+export type RendersManyOpts = RendersOneOrManyOpts;

package/dist/types/src/serializer/decorators/associations/RendersOne.d.ts

@@ -0,0 +1,46 @@
+import { SerializableClassOrClasses } from '../../../dream/types.js';
+import { RendersOneOrManyOpts } from './shared.js';
+/**
+ * Establishes a One to One relationship between
+ * the base serializer and the child serializer
+ *
+ * This relationship is similar to a RendersMany relationship,
+ * except that it will only render one item. It is generally
+ * used to correspond with HasOne and BelongsTo associations
+ * on the models being driven through the serializer.
+ *
+ * If no argument is provided to RendersOne, it will infer the serializer
+ * by looking to the default serializer of the model
+ *
+ * ```ts
+ * class User extends ApplicationModel {
+ *   @Deco.HasOne('Settings')
+ *   public settings: Settings
+ * }
+ *
+ * class Settings extends ApplicationModel {
+ *   @Deco.BelongsTo('User')
+ *   public user: User
+ * }
+ *
+ * class UserSerializer {
+ *   @RendersOne()
+ *   public settings: Settings
+ * }
+ * ```
+ *
+ * An explicit serializer can also be provided:
+ *
+ * ```ts
+ * class UserSerializer {
+ *   @RendersOne(() => SettingsSummarySerializer)
+ *   public settings: Settings
+ * }
+ * ```
+ *
+ * @param opts.flatten - whether or not to flatten the association's attributes into this serializer when rendering. Defaults to false.
+ */
+export default function RendersOne(serializableClassOrClasses?: SerializableClassOrClasses | RendersOneOpts | null, opts?: RendersOneOpts): any;
+export interface RendersOneOpts extends RendersOneOrManyOpts {
+    flatten?: boolean;
+}

package/dist/types/src/serializer/decorators/associations/shared.d.ts

@@ -0,0 +1,23 @@
+import { DreamConst, SerializableClassOrClasses } from '../../../dream/types.js';
+export type SerializableAssociationType = 'RendersOne' | 'RendersMany';
+export interface DreamSerializerAssociationStatement {
+    field: string;
+    flatten: boolean;
+    optional: boolean;
+    dreamOrSerializerClass: SerializableClassOrClasses | null;
+    source: string | typeof DreamConst.passthrough;
+    through: string | null;
+    type: SerializableAssociationType;
+    path: string | null;
+    exportedAs: string | null;
+    serializerKey?: string;
+}
+export interface RendersOneOrManyOpts {
+    optional?: boolean;
+    source?: string | typeof DreamConst.passthrough;
+    through?: string;
+    path?: string;
+    exportedAs?: string;
+    serializerKey?: string;
+}
+export declare function isSerializable(dreamOrSerializerClass: any): boolean;