@cookbook/urlkit 1.0.0

package/dist/schema/date.d.ts

@@ -0,0 +1,14 @@
+import type { DateFormatCodec } from '../date/contracts.js';
+import type { RequiredRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaOptions } from './contracts.js';
+export type BuiltInRuntimeDateFormat = 'date' | 'date-time' | 'unix-seconds' | 'unix-ms';
+export type RuntimeDateFormat = BuiltInRuntimeDateFormat | DateFormatCodec;
+export interface DateSchemaOptions<Format extends RuntimeDateFormat = RuntimeDateFormat> extends RuntimeSchemaOptions {
+    readonly format: Format;
+}
+export interface DateSchema<Format extends RuntimeDateFormat = 'date'> extends RuntimeSchemaBuilder<Date, 'date', DateSchemaOptions<Format>, RequiredRuntimeSchemaDescriptor<'date', DateSchemaOptions<Format>>> {
+}
+export interface DateOptions<Format extends RuntimeDateFormat = 'date'> {
+    readonly format?: Format;
+}
+export declare function date(): DateSchema;
+export declare function date<const Format extends RuntimeDateFormat>(options: DateOptions<Format>): DateSchema<Format>;

package/dist/schema/enum-of.d.ts

@@ -0,0 +1,7 @@
+import type { RequiredRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaOptions } from './contracts.js';
+export interface EnumSchemaOptions<Values extends readonly string[]> extends RuntimeSchemaOptions {
+    readonly values: Values;
+}
+export interface EnumSchema<Values extends readonly string[]> extends RuntimeSchemaBuilder<Values[number], 'enum', EnumSchemaOptions<Values>, RequiredRuntimeSchemaDescriptor<'enum', EnumSchemaOptions<Values>>> {
+}
+export declare function enumOf<const Values extends readonly string[]>(values: Values): EnumSchema<Values>;

package/dist/schema/get-runtime-schema-internals.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaOptions } from './contracts.js';
+export declare function getRuntimeSchemaInternals<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>>(schema: RuntimeSchemaBuilder<Value, Kind, Options, Descriptor>): import("./contracts.js").RuntimeSchemaInternals<Value, Kind, Options, Descriptor>;

package/dist/schema/handle-runtime-schema-absence.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizedRuntimeSchemaDescriptor, RuntimeSchemaOptions, RuntimeSchemaValueOptions } from './contracts.js';
+export interface RuntimeSchemaAbsenceResult<Value> {
+    readonly handled: boolean;
+    readonly value?: Value | undefined;
+}
+export declare function handleRuntimeSchemaAbsence<Value, Options extends RuntimeSchemaOptions = RuntimeSchemaOptions>(descriptor: NormalizedRuntimeSchemaDescriptor<string, Options, Value>, input: unknown, options?: RuntimeSchemaValueOptions): RuntimeSchemaAbsenceResult<Value>;

package/dist/schema/int.d.ts

@@ -0,0 +1,4 @@
+import type { EmptyRuntimeSchemaOptions, RequiredRuntimeSchemaDescriptor, RuntimeSchemaBuilder } from './contracts.js';
+export interface IntSchema extends RuntimeSchemaBuilder<number, 'int', EmptyRuntimeSchemaOptions, RequiredRuntimeSchemaDescriptor<'int', EmptyRuntimeSchemaOptions>> {
+}
+export declare function int(): IntSchema;

package/dist/schema/is-runtime-schema-kind.d.ts

@@ -0,0 +1,2 @@
+import type { AnyRuntimeSchemaBuilder } from './contracts.js';
+export declare function isRuntimeSchemaKind(schema: AnyRuntimeSchemaBuilder, kind: string): boolean;

package/dist/schema/normalize-compiled-runtime-schema-value.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeSchemaValueOptions } from './contracts.js';
+import type { CompiledRuntimeSchema } from './compile-runtime-schema-value.js';
+export declare function normalizeCompiledRuntimeSchemaValue<Value = unknown>(compiled: CompiledRuntimeSchema<Value>, input: unknown, options?: RuntimeSchemaValueOptions): Value;

package/dist/schema/normalize-runtime-schema-value.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaOptions, RuntimeSchemaValueOptions } from './contracts.js';
+export declare function normalizeRuntimeSchemaValue<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>>(schema: RuntimeSchemaBuilder<Value, Kind, Options, Descriptor>, input: unknown, options?: RuntimeSchemaValueOptions): Value;

package/dist/schema/number.d.ts

@@ -0,0 +1,4 @@
+import type { EmptyRuntimeSchemaOptions, RequiredRuntimeSchemaDescriptor, RuntimeSchemaBuilder } from './contracts.js';
+export interface NumberSchema extends RuntimeSchemaBuilder<number, 'number', EmptyRuntimeSchemaOptions, RequiredRuntimeSchemaDescriptor<'number', EmptyRuntimeSchemaOptions>> {
+}
+export declare function number(): NumberSchema;

package/dist/schema/object.d.ts

@@ -0,0 +1,20 @@
+import type { AnyRuntimeSchemaBuilder, InferRuntimeSchemaValue, NormalizedRuntimeSchemaDescriptor, RequiredRuntimeSchemaDescriptor, RuntimeSchemaOptions, RuntimeSchemaBuilder } from './contracts.js';
+export type ObjectSchemaShape = Readonly<Record<string, AnyRuntimeSchemaBuilder>>;
+export interface ObjectSchemaOptions extends RuntimeSchemaOptions {
+    readonly shape: Readonly<Record<string, NormalizedRuntimeSchemaDescriptor>>;
+}
+export interface ObjectSchema<Shape extends ObjectSchemaShape, Value = InferObjectShape<Shape>, Descriptor extends NormalizedRuntimeSchemaDescriptor<'object', ObjectSchemaOptions> = RequiredRuntimeSchemaDescriptor<'object', ObjectSchemaOptions>> extends RuntimeSchemaBuilder<Value, 'object', ObjectSchemaOptions, Descriptor> {
+}
+export type AnyObjectSchema = ObjectSchema<any, any, any>;
+export type InferObjectShape<Shape extends ObjectSchemaShape> = Simplify<{
+    readonly [Key in keyof Shape as IsOptionalObjectField<Shape[Key]> extends true ? never : Key]: InferRuntimeSchemaValue<Shape[Key]>;
+} & {
+    readonly [Key in keyof Shape as IsOptionalObjectField<Shape[Key]> extends true ? Key : never]?: Exclude<InferRuntimeSchemaValue<Shape[Key]>, undefined>;
+}>;
+export declare function object<const Shape extends ObjectSchemaShape>(shape: Shape): ObjectSchema<Shape>;
+export declare function getObjectSchemaShape<Shape extends ObjectSchemaShape>(schema: ObjectSchema<Shape, any, any>): Shape;
+type IsOptionalObjectField<Schema extends AnyRuntimeSchemaBuilder> = undefined extends InferRuntimeSchemaValue<Schema> ? true : false;
+type Simplify<Value> = {
+    readonly [Key in keyof Value]: Value[Key];
+} & {};
+export {};

package/dist/schema/parse-compiled-runtime-schema-value.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeSchemaValueOptions } from './contracts.js';
+import type { CompiledRuntimeSchema } from './compile-runtime-schema-value.js';
+export declare function parseCompiledRuntimeSchemaValue<Value = unknown>(compiled: CompiledRuntimeSchema<Value>, input: unknown, options?: RuntimeSchemaValueOptions): Value;

package/dist/schema/parse-runtime-schema-value.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaOptions, RuntimeSchemaValueOptions } from './contracts.js';
+export declare function parseRuntimeSchemaValue<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>>(schema: RuntimeSchemaBuilder<Value, Kind, Options, Descriptor>, input: unknown, options?: RuntimeSchemaValueOptions): Value;

package/dist/schema/runtime-schema-symbol.d.ts

@@ -0,0 +1,5 @@
+import type { NormalizedRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaInternals, RuntimeSchemaOptions } from './contracts.js';
+export declare const runtimeSchemaSymbol: unique symbol;
+export interface RuntimeSchemaBuilderWithInternals<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>> extends RuntimeSchemaBuilder<Value, Kind, Options, Descriptor> {
+    readonly [runtimeSchemaSymbol]: RuntimeSchemaInternals<Value, Kind, Options, Descriptor>;
+}

package/dist/schema/runtime-schema-value-context.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSchemaValueContext, RuntimeSchemaValueOptions } from './contracts.js';
+export declare function createRuntimeSchemaValueContext(kind: string, options?: RuntimeSchemaValueOptions): RuntimeSchemaValueContext;

package/dist/schema/safe-runtime-schema-value.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizedRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaOptions, RuntimeSchemaSafeResult, RuntimeSchemaValueOptions } from './contracts.js';
+export declare function safeParseRuntimeSchemaValue<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>>(schema: RuntimeSchemaBuilder<Value, Kind, Options, Descriptor>, input: unknown, options?: RuntimeSchemaValueOptions): RuntimeSchemaSafeResult<Value>;
+export declare function safeNormalizeRuntimeSchemaValue<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>>(schema: RuntimeSchemaBuilder<Value, Kind, Options, Descriptor>, input: unknown, options?: RuntimeSchemaValueOptions): RuntimeSchemaSafeResult<Value>;
+export declare function safeSerializeRuntimeSchemaValue<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>>(schema: RuntimeSchemaBuilder<Value, Kind, Options, Descriptor>, input: unknown, options?: RuntimeSchemaValueOptions): RuntimeSchemaSafeResult<string | undefined>;

package/dist/schema/serialize-compiled-runtime-schema-value.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeSchemaValueOptions } from './contracts.js';
+import type { CompiledRuntimeSchema } from './compile-runtime-schema-value.js';
+export declare function serializeCompiledRuntimeSchemaValue<Value = unknown>(compiled: CompiledRuntimeSchema<Value>, input: unknown, options?: RuntimeSchemaValueOptions): string | undefined;

package/dist/schema/serialize-runtime-schema-value.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedRuntimeSchemaDescriptor, RuntimeSchemaBuilder, RuntimeSchemaOptions, RuntimeSchemaValueOptions } from './contracts.js';
+export declare function serializeRuntimeSchemaValue<Value, Kind extends string, Options extends RuntimeSchemaOptions, Descriptor extends NormalizedRuntimeSchemaDescriptor<Kind, Options>>(schema: RuntimeSchemaBuilder<Value, Kind, Options, Descriptor>, input: unknown, options?: RuntimeSchemaValueOptions): string | undefined;

package/dist/schema/string.d.ts

@@ -0,0 +1,4 @@
+import type { EmptyRuntimeSchemaOptions, RequiredRuntimeSchemaDescriptor, RuntimeSchemaBuilder } from './contracts.js';
+export interface StringSchema extends RuntimeSchemaBuilder<string, 'string', EmptyRuntimeSchemaOptions, RequiredRuntimeSchemaDescriptor<'string', EmptyRuntimeSchemaOptions>> {
+}
+export declare function string(): StringSchema;

package/dist/search/append-object-search-entries.d.ts

@@ -0,0 +1,4 @@
+import type { BuildSearchOptions } from '../contracts.js';
+import { type AnyObjectSchema } from '../schema/object.js';
+import type { SearchEntry } from './search-entries.js';
+export declare function appendObjectSearchEntries(entries: SearchEntry[], parentKey: string, schema: AnyObjectSchema, value: unknown, options?: BuildSearchOptions): void;

package/dist/search/append-raw-search-value.d.ts

@@ -0,0 +1,2 @@
+import type { RawSearchValue } from './contracts.js';
+export declare function appendRawSearchValue(output: Record<string, RawSearchValue>, key: string, value: string): void;

package/dist/search/append-search-entry.d.ts

@@ -0,0 +1,3 @@
+import type { BuildSearchOptions } from '../contracts.js';
+import type { SearchEntry } from './search-entries.js';
+export declare function appendSearchEntry(entries: SearchEntry[], key: string, value: string | readonly string[] | undefined, options?: BuildSearchOptions): void;

package/dist/search/are-search-values-equal.d.ts

@@ -0,0 +1 @@
+export declare function areSearchValuesEqual(left: unknown, right: unknown): boolean;

package/dist/search/assert-object-search-collisions.d.ts

@@ -0,0 +1,2 @@
+import type { RawSearchParams } from './contracts.js';
+export declare function assertNoObjectSearchCollisions(parentKey: string, rawSearch: RawSearchParams, parentPath: readonly string[]): void;

package/dist/search/build-compiled-search.d.ts

@@ -0,0 +1,3 @@
+import type { BuildSearchOptions } from '../contracts.js';
+import type { CompiledSearchSchema } from './contracts.js';
+export declare function buildCompiledSearch(input: Record<string, unknown> | undefined, compiled: CompiledSearchSchema, options?: BuildSearchOptions): string;

package/dist/search/build-raw-search.d.ts

@@ -0,0 +1,2 @@
+import type { BuildSearchOptions } from '../contracts.js';
+export declare function buildRawSearch(input?: Record<string, unknown>, options?: BuildSearchOptions): string;

package/dist/search/build-schema-search.d.ts

@@ -0,0 +1,3 @@
+import type { BuildSearchOptions } from '../contracts.js';
+import type { RuntimeSearchSchema } from './contracts.js';
+export declare function buildSchemaSearch(input: Record<string, unknown> | undefined, schema: RuntimeSearchSchema, options?: BuildSearchOptions): string;

package/dist/search/build-search.d.ts

@@ -0,0 +1,6 @@
+import type { BuildSearchOptions, SearchInputArgument } from '../contracts.js';
+import type { InferRuntimeSearchBuildInput, RuntimeSearchSchema, SearchBuildOptions } from './contracts.js';
+export declare function buildSearch<const Schema extends RuntimeSearchSchema>(input: SearchInputArgument<InferRuntimeSearchBuildInput<Schema>>, options: SearchBuildOptions<Schema> & {
+    readonly schema: Schema;
+}): string;
+export declare function buildSearch(input?: Record<string, unknown>, options?: BuildSearchOptions): string;

package/dist/search/collect-object-search-paths.d.ts

@@ -0,0 +1,2 @@
+import { type AnyObjectSchema } from '../schema/object.js';
+export declare function collectObjectSearchPaths(schema: AnyObjectSchema): readonly (readonly string[])[];

package/dist/search/compile-search-schema.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledSearchSchema, RuntimeSearchSchema } from './contracts.js';
+export declare function compileSearchSchema(schema: RuntimeSearchSchema): CompiledSearchSchema;

package/dist/search/contracts.d.ts

@@ -0,0 +1,73 @@
+import type { BuildSearchOptions, PatchSearchOptions, SearchArrayFormat, UnknownSearchBehavior, UnknownSearchParams } from '../contracts.js';
+import type { InferRuntimeSchemaValue, RuntimeSchemaBuilder } from '../schema/contracts.js';
+import type { CompiledRuntimeSchema } from '../schema/compile-runtime-schema-value.js';
+export type AnyRuntimeSchemaBuilder = RuntimeSchemaBuilder<any, any, any, any>;
+export type RawSearchValue = string | readonly string[];
+export type RawSearchParams = Readonly<Record<string, RawSearchValue>>;
+export type SearchFieldType = 'one' | 'many';
+export interface RuntimeSearchField<Schema extends AnyRuntimeSchemaBuilder = AnyRuntimeSchemaBuilder> {
+    readonly type?: SearchFieldType;
+    readonly value: Schema;
+    readonly optional?: boolean;
+    readonly default?: unknown;
+}
+export type RuntimeSearchFieldInput = AnyRuntimeSchemaBuilder | RuntimeSearchField;
+export type RuntimeSearchSchema = Readonly<Record<string, RuntimeSearchFieldInput>>;
+export interface ParseSearchOptions<SearchDescriptor = unknown> {
+    readonly schema?: SearchDescriptor;
+    readonly unknownSearch?: UnknownSearchBehavior;
+    readonly arrayFormat?: SearchArrayFormat;
+}
+export interface SearchBuildOptions<SearchDescriptor = unknown> extends BuildSearchOptions {
+    readonly schema?: SearchDescriptor;
+}
+export interface SearchPatchOptions<SearchDescriptor = unknown> extends PatchSearchOptions {
+    readonly schema?: SearchDescriptor;
+}
+export interface SearchParseResult<Search> {
+    readonly search: Search;
+    readonly unknownSearch?: UnknownSearchParams;
+}
+export interface CompiledSearchField {
+    readonly key: string;
+    readonly type: SearchFieldType;
+    readonly schema: AnyRuntimeSchemaBuilder;
+    readonly compiledSchema: CompiledRuntimeSchema;
+    readonly presence: 'required' | 'optional' | 'defaulted';
+    readonly defaultValue?: unknown;
+}
+export interface CompiledSearchSchema {
+    readonly fields: readonly CompiledSearchField[];
+    readonly keys: ReadonlySet<string>;
+}
+export interface SearchBuildContext {
+    readonly options?: SearchBuildOptions;
+}
+export interface SearchParseOptions {
+    readonly arrayFormat?: SearchArrayFormat;
+}
+export interface SearchPatchContext {
+    readonly options?: PatchSearchOptions;
+}
+export type InferRuntimeSearchBuildInput<Schema extends RuntimeSearchSchema> = Simplify<{
+    readonly [Key in keyof Schema as IsRequiredSearchBuildField<Schema[Key]> extends true ? Key : never]: InferSearchFieldValue<Schema[Key]>;
+} & {
+    readonly [Key in keyof Schema as IsRequiredSearchBuildField<Schema[Key]> extends true ? never : Key]?: Exclude<InferSearchFieldValue<Schema[Key]>, undefined>;
+}>;
+export type InferRuntimeSearch<Schema extends RuntimeSearchSchema> = Simplify<{
+    readonly [Key in keyof Schema as IsOptionalSearchField<Schema[Key]> extends true ? never : Key]: InferSearchFieldValue<Schema[Key]>;
+} & {
+    readonly [Key in keyof Schema as IsOptionalSearchField<Schema[Key]> extends true ? Key : never]?: Exclude<InferSearchFieldValue<Schema[Key]>, undefined>;
+}>;
+type InferSearchFieldValue<Field> = Field extends RuntimeSearchField<infer Schema> ? Field['type'] extends 'many' ? readonly InferSearchElementValue<Schema>[] : InferRuntimeSchemaValue<Schema> : Field extends AnyRuntimeSchemaBuilder ? InferRuntimeSchemaValue<Field> : never;
+type InferSearchElementValue<Schema extends AnyRuntimeSchemaBuilder> = Exclude<InferRuntimeSchemaValue<Schema>, undefined>;
+type IsOptionalSearchField<Field> = Field extends RuntimeSearchField<infer Schema> ? 'default' extends keyof Field ? false : Field['optional'] extends true ? true : Field['type'] extends 'many' ? false : IsOptionalSchema<Schema> : Field extends AnyRuntimeSchemaBuilder ? IsOptionalSchema<Field> : false;
+type IsOptionalSchema<Schema extends AnyRuntimeSchemaBuilder> = undefined extends InferRuntimeSchemaValue<Schema> ? true : false;
+type IsRequiredSearchBuildField<Field> = Field extends RuntimeSearchField<infer Schema> ? 'default' extends keyof Field ? false : Field['optional'] extends true ? false : Field['type'] extends 'many' ? true : IsRequiredSchema<Schema> : Field extends AnyRuntimeSchemaBuilder ? IsRequiredSchema<Field> : false;
+type IsRequiredSchema<Schema extends AnyRuntimeSchemaBuilder> = Schema extends RuntimeSchemaBuilder<any, any, any, infer Descriptor> ? Descriptor extends {
+    readonly presence: 'required';
+} ? true : false : false;
+type Simplify<Value> = {
+    readonly [Key in keyof Value]: Value[Key];
+} & {};
+export {};

package/dist/search/copy-raw-search-params.d.ts

@@ -0,0 +1,2 @@
+import type { RawSearchParams } from './contracts.js';
+export declare function copyRawSearchParams(input: RawSearchParams): RawSearchParams;

package/dist/search/copy-unknown-structured-search.d.ts

@@ -0,0 +1,2 @@
+import type { UnknownSearchParams } from '../contracts.js';
+export declare function copyUnknownStructuredSearch(input: Readonly<Record<string, unknown>>): UnknownSearchParams | undefined;

package/dist/search/create-search-params.d.ts

@@ -0,0 +1 @@
+export declare function createSearchParams(input: string | URLSearchParams): URLSearchParams;

package/dist/search/create-search.d.ts

@@ -0,0 +1,4 @@
+import type { EmptyParams } from '../contracts.js';
+import type { CreateUrlOptions, UrlContract } from '../url/contracts.js';
+import type { InferRuntimeSearch, InferRuntimeSearchBuildInput, RuntimeSearchSchema } from './contracts.js';
+export declare function search<const Schema extends RuntimeSearchSchema>(schema: Schema, options?: CreateUrlOptions): UrlContract<'pathless', string, EmptyParams, InferRuntimeSearch<Schema>, undefined, InferRuntimeSearchBuildInput<Schema>>;

package/dist/search/delete-search-field-raw-keys.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledSearchField } from './contracts.js';
+export declare function deleteSearchFieldRawKeys(field: CompiledSearchField, rawSearch: Record<string, unknown>): void;

package/dist/search/filter-raw-search.d.ts

@@ -0,0 +1,3 @@
+import type { RawSearchParams } from './contracts.js';
+export declare function omitRawSearch(input: RawSearchParams, keys: readonly string[]): RawSearchParams;
+export declare function pickRawSearch(input: RawSearchParams, keys: readonly string[]): RawSearchParams;

package/dist/search/find-object-search-raw-value.d.ts

@@ -0,0 +1,2 @@
+import type { RawSearchParams, RawSearchValue } from './contracts.js';
+export declare function findObjectSearchRawValue(parentKey: string, path: readonly string[], rawSearch: RawSearchParams): RawSearchValue | undefined;

package/dist/search/has-search-field-raw-value.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledSearchField, RawSearchParams } from './contracts.js';
+export declare function hasSearchFieldRawValue(field: CompiledSearchField, rawSearch: RawSearchParams): boolean;

package/dist/search/is-runtime-search-field.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSearchField } from './contracts.js';
+export declare function isRuntimeSearchField(input: unknown): input is RuntimeSearchField;

package/dist/search/join-search-strings.d.ts

@@ -0,0 +1 @@
+export declare function joinSearchStrings(...parts: readonly string[]): string;

package/dist/search/normalize-compiled-search.d.ts

@@ -0,0 +1,3 @@
+import type { UnknownSearchBehavior } from '../contracts.js';
+import type { CompiledSearchSchema, SearchParseResult } from './contracts.js';
+export declare function normalizeCompiledSearch(input: unknown, compiled: CompiledSearchSchema | undefined, unknownSearch?: UnknownSearchBehavior): SearchParseResult<Record<string, unknown>>;

package/dist/search/normalize-search-build-value.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledSearchField } from './contracts.js';
+export declare function normalizeSearchBuildValue(field: CompiledSearchField, input: unknown): unknown;

package/dist/search/normalize-search-field-default.d.ts

@@ -0,0 +1,2 @@
+import type { AnyRuntimeSchemaBuilder, SearchFieldType } from './contracts.js';
+export declare function normalizeSearchFieldDefault(fieldType: SearchFieldType, schema: AnyRuntimeSchemaBuilder, value: unknown, path: readonly string[]): unknown;

package/dist/search/normalize-search-field-type.d.ts

@@ -0,0 +1,2 @@
+import type { SearchFieldType } from './contracts.js';
+export declare function normalizeSearchFieldType(input: unknown): SearchFieldType;

package/dist/search/object-search-key.d.ts

@@ -0,0 +1,4 @@
+export declare function joinObjectSearchKey(parentKey: string, childKey: string): string;
+export declare function escapeObjectSearchSegment(segment: string): string;
+export declare function unescapeObjectSearchSegment(segment: string): string;
+export declare function splitObjectSearchKey(key: string): readonly string[];

package/dist/search/object-search-path-key.d.ts

@@ -0,0 +1,2 @@
+export declare function createObjectSearchPathKey(path: readonly string[]): string;
+export declare function isObjectSearchPathEqual(left: readonly string[], right: readonly string[]): boolean;

package/dist/search/object-search-raw-key-path.d.ts

@@ -0,0 +1 @@
+export declare function getObjectSearchRawKeyPath(parentKey: string, rawKey: string): readonly string[] | undefined;

package/dist/search/omit-search.d.ts

@@ -0,0 +1 @@
+export declare function omitSearch(current: string | URLSearchParams, keys: readonly string[]): string;

package/dist/search/parse-array-search-value.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeSchemaValueContext } from '../schema/contracts.js';
+import { type ArraySchema } from '../schema/array.js';
+import type { RawSearchValue, SearchParseOptions } from './contracts.js';
+export declare function parseArraySearchValue(schema: ArraySchema<any>, value: RawSearchValue | undefined, context: RuntimeSchemaValueContext, options?: SearchParseOptions): unknown;

package/dist/search/parse-compiled-search.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledSearchSchema, RawSearchParams, SearchParseOptions, SearchParseResult } from './contracts.js';
+export declare function parseCompiledSearch(rawSearch: RawSearchParams, compiled: CompiledSearchSchema, unknownSearch?: 'strip' | 'preserve' | 'error', options?: SearchParseOptions): SearchParseResult<Record<string, unknown>>;

package/dist/search/parse-object-search-value.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeSchemaValueContext } from '../schema/contracts.js';
+import { type AnyObjectSchema } from '../schema/object.js';
+import type { RawSearchParams, SearchParseOptions } from './contracts.js';
+export declare function parseObjectSearchValue(schema: AnyObjectSchema, parentKey: string, rawSearch: RawSearchParams, context: RuntimeSchemaValueContext, options?: SearchParseOptions): unknown;

package/dist/search/parse-partial-compiled-search.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledSearchSchema, RawSearchParams, SearchParseOptions } from './contracts.js';
+export interface PartialCompiledSearchParseResult {
+    readonly search: Record<string, unknown>;
+    readonly unknownSearch: RawSearchParams;
+}
+export declare function parsePartialCompiledSearch(rawSearch: RawSearchParams, compiled: CompiledSearchSchema, options?: SearchParseOptions): PartialCompiledSearchParseResult;

package/dist/search/parse-partial-schema-search.d.ts

@@ -0,0 +1,6 @@
+import type { RawSearchParams, RuntimeSearchSchema, SearchParseOptions } from './contracts.js';
+export interface PartialSchemaSearchParseResult {
+    readonly search: Record<string, unknown>;
+    readonly unknownSearch: RawSearchParams;
+}
+export declare function parsePartialSchemaSearch(rawSearch: RawSearchParams, schema: RuntimeSearchSchema, options?: SearchParseOptions): PartialSchemaSearchParseResult;

package/dist/search/parse-raw-search.d.ts

@@ -0,0 +1,2 @@
+import type { RawSearchParams } from './contracts.js';
+export declare function parseRawSearch(input: string | URLSearchParams): RawSearchParams;

package/dist/search/parse-search-field-value.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledSearchField, RawSearchParams, SearchParseOptions } from './contracts.js';
+export declare function parseSearchFieldValue(field: CompiledSearchField, rawSearch: RawSearchParams, options?: SearchParseOptions): unknown;

package/dist/search/parse-search.d.ts

@@ -0,0 +1,5 @@
+import type { InferRuntimeSearch, ParseSearchOptions, RawSearchParams, RuntimeSearchSchema, SearchParseResult } from './contracts.js';
+export declare function parseSearch(input: string | URLSearchParams): RawSearchParams;
+export declare function parseSearch<const Schema extends RuntimeSearchSchema>(input: string | URLSearchParams, options: ParseSearchOptions<Schema> & {
+    readonly schema: Schema;
+}): SearchParseResult<InferRuntimeSearch<Schema>>;

package/dist/search/patch-search.d.ts

@@ -0,0 +1,6 @@
+import type { PatchSearchOptions } from '../contracts.js';
+import type { InferRuntimeSearch, RuntimeSearchSchema, SearchPatchOptions } from './contracts.js';
+export declare function patchSearch<const Schema extends RuntimeSearchSchema>(current: string | URLSearchParams, patch: Partial<InferRuntimeSearch<Schema>>, options: SearchPatchOptions<Schema> & {
+    readonly schema: Schema;
+}): string;
+export declare function patchSearch(current: string | URLSearchParams, patch: Record<string, unknown>, options?: PatchSearchOptions): string;

package/dist/search/pick-search.d.ts

@@ -0,0 +1 @@
+export declare function pickSearch(current: string | URLSearchParams, keys: readonly string[]): string;

package/dist/search/replace-search.d.ts

@@ -0,0 +1,5 @@
+import type { InferRuntimeSearchBuildInput, RuntimeSearchSchema, SearchBuildOptions } from './contracts.js';
+export declare function replaceSearch<const Schema extends RuntimeSearchSchema>(current: string | URLSearchParams, next: InferRuntimeSearchBuildInput<Schema>, options: SearchBuildOptions<Schema> & {
+    readonly schema: Schema;
+}): string;
+export declare function replaceSearch(current: string | URLSearchParams, next: Record<string, unknown>, options?: SearchBuildOptions): string;

package/dist/search/search-array-format.d.ts

@@ -0,0 +1,3 @@
+import type { SearchArrayFormat } from '../contracts.js';
+import type { RawSearchValue } from './contracts.js';
+export declare function readArraySearchValues(value: RawSearchValue | undefined, arrayFormat?: SearchArrayFormat): readonly string[] | undefined;

package/dist/search/search-entries.d.ts

@@ -0,0 +1,4 @@
+export interface SearchEntry {
+    readonly key: string;
+    readonly value: string;
+}

package/dist/search/serialize-search-build-value.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledSearchField } from './contracts.js';
+export declare function serializeSearchBuildValue(field: CompiledSearchField, normalized: unknown): string | readonly string[] | undefined;

package/dist/search/serialize-search-entries.d.ts

@@ -0,0 +1,3 @@
+import type { BuildSearchOptions } from '../contracts.js';
+import type { SearchEntry } from './search-entries.js';
+export declare function serializeSearchEntries(entries: readonly SearchEntry[], options?: BuildSearchOptions): string;

package/dist/static/compile-static-hash.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedHashDescriptor } from '../hash/contracts.js';
+import type { InferStaticHash, StaticHashDescriptor } from './contracts.js';
+export declare function compileStaticHash<Descriptor extends StaticHashDescriptor>(descriptor: Descriptor): NormalizedHashDescriptor<InferStaticHash<Descriptor>>;

package/dist/static/compile-static-search.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeSearchSchema } from '../search/contracts.js';
+import type { StaticSearchDescriptor } from './contracts.js';
+export declare function compileStaticSearch(descriptor: StaticSearchDescriptor): RuntimeSearchSchema;

package/dist/static/compile-static-url.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedUrlDescriptor } from '../url/contracts.js';
+import type { CompileStaticUrlOptions, StaticUrlDescriptor, StaticUrlModeFromDescriptor } from './contracts.js';
+export declare function compileStaticUrl<Descriptor extends StaticUrlDescriptor>(descriptor: Descriptor, options?: CompileStaticUrlOptions): NormalizedUrlDescriptor<StaticUrlModeFromDescriptor<Descriptor>>;

package/dist/static/contracts.d.ts

@@ -0,0 +1,81 @@
+import type { PathConstraintMap } from '../contracts.js';
+export interface CompileStaticUrlOptions {
+    readonly pathConstraints?: PathConstraintMap;
+}
+export interface StaticUrlDescriptor {
+    readonly path?: string;
+    readonly search?: StaticSearchDescriptor;
+    readonly hash?: StaticHashDescriptor;
+}
+export type StaticUrlModeFromDescriptor<Descriptor extends StaticUrlDescriptor> = Descriptor extends {
+    readonly path: string;
+} ? 'path' : 'pathless';
+export type InferStaticUrlSearch<Descriptor extends StaticUrlDescriptor> = Descriptor extends {
+    readonly search: infer SearchDescriptor extends StaticSearchDescriptor;
+} ? InferStaticSearch<SearchDescriptor> : {};
+export type InferStaticUrlSearchBuildInput<Descriptor extends StaticUrlDescriptor> = Descriptor extends {
+    readonly search: infer SearchDescriptor extends StaticSearchDescriptor;
+} ? InferStaticSearchBuildInput<SearchDescriptor> : {};
+export type InferStaticUrlHash<Descriptor extends StaticUrlDescriptor> = Descriptor extends {
+    readonly hash: infer HashDescriptor extends StaticHashDescriptor;
+} ? InferStaticHash<HashDescriptor> : undefined;
+export type InferStaticUrlHashBuildInput<Descriptor extends StaticUrlDescriptor> = Descriptor extends {
+    readonly hash: infer HashDescriptor extends StaticHashDescriptor;
+} ? InferStaticHashBuildInput<HashDescriptor> : undefined;
+export type StaticSearchDescriptor = Readonly<Record<string, StaticSearchField>>;
+export type StaticSearchField = StaticSearchValue | StaticSearchFieldObject;
+export interface StaticSearchFieldObject {
+    readonly type?: 'one' | 'many';
+    readonly optional?: boolean;
+    readonly value?: StaticSearchValue;
+    readonly default?: unknown;
+}
+export type StaticSearchValue = 'string' | 'number' | 'int' | 'boolean' | 'date' | 'date-time' | 'unix-seconds' | 'unix-ms' | StaticDateSearchValue | StaticEnumSearchValue;
+export interface StaticDateSearchValue {
+    readonly type: 'date';
+    readonly format?: StaticDateFormat;
+}
+export type StaticDateFormat = 'date' | 'date-time' | 'unix-seconds' | 'unix-ms';
+export interface StaticEnumSearchValue {
+    readonly type: 'enum';
+    readonly values: readonly string[];
+}
+export type InferStaticSearch<Descriptor extends StaticSearchDescriptor> = Simplify<{
+    readonly [Key in keyof Descriptor as IsOptionalStaticSearchField<Descriptor[Key]> extends true ? never : Key]: InferStaticSearchFieldValue<Descriptor[Key]>;
+} & {
+    readonly [Key in keyof Descriptor as IsOptionalStaticSearchField<Descriptor[Key]> extends true ? Key : never]?: InferStaticSearchFieldValue<Descriptor[Key]>;
+}>;
+export type InferStaticSearchBuildInput<Descriptor extends StaticSearchDescriptor> = Simplify<{
+    readonly [Key in keyof Descriptor as IsRequiredStaticSearchBuildField<Descriptor[Key]> extends true ? Key : never]: InferStaticSearchFieldValue<Descriptor[Key]>;
+} & {
+    readonly [Key in keyof Descriptor as IsRequiredStaticSearchBuildField<Descriptor[Key]> extends true ? never : Key]?: InferStaticSearchFieldValue<Descriptor[Key]>;
+}>;
+export type StaticHashDescriptor = readonly string[] | StaticStringHashDescriptor | StaticEnumHashDescriptor;
+export interface StaticStringHashDescriptor {
+    readonly type: 'string';
+    readonly optional?: boolean;
+    readonly default?: string;
+}
+export interface StaticEnumHashDescriptor {
+    readonly type: 'enum';
+    readonly values: readonly string[];
+    readonly optional?: boolean;
+    readonly default?: string;
+}
+export type InferStaticHash<Descriptor extends StaticHashDescriptor> = Descriptor extends readonly string[] ? Descriptor[number] | undefined : Descriptor extends StaticStringHashDescriptor ? InferStaticStringHash<Descriptor> : Descriptor extends StaticEnumHashDescriptor ? InferStaticEnumHash<Descriptor> : never;
+type InferStaticStringHash<Descriptor extends StaticStringHashDescriptor> = 'default' extends keyof Descriptor ? string : Descriptor['optional'] extends true ? string | undefined : string;
+type InferStaticEnumHash<Descriptor extends StaticEnumHashDescriptor> = 'default' extends keyof Descriptor ? Descriptor['values'][number] : Descriptor['optional'] extends true ? Descriptor['values'][number] | undefined : Descriptor['values'][number];
+export type InferStaticHashBuildInput<Descriptor extends StaticHashDescriptor> = Descriptor extends readonly string[] ? Descriptor[number] | undefined : Descriptor extends StaticStringHashDescriptor ? InferStaticStringHashBuildInput<Descriptor> : Descriptor extends StaticEnumHashDescriptor ? InferStaticEnumHashBuildInput<Descriptor> : never;
+type InferStaticStringHashBuildInput<Descriptor extends StaticStringHashDescriptor> = 'default' extends keyof Descriptor ? string | undefined : Descriptor['optional'] extends true ? string | undefined : string;
+type InferStaticEnumHashBuildInput<Descriptor extends StaticEnumHashDescriptor> = 'default' extends keyof Descriptor ? Descriptor['values'][number] | undefined : Descriptor['optional'] extends true ? Descriptor['values'][number] | undefined : Descriptor['values'][number];
+type InferStaticSearchFieldValue<Field> = Field extends StaticSearchFieldObject ? Field['type'] extends 'many' ? readonly InferStaticSearchValue<StaticFieldObjectValue<Field>>[] : InferStaticSearchValue<StaticFieldObjectValue<Field>> : InferStaticSearchValue<Field>;
+type StaticFieldObjectValue<Field extends StaticSearchFieldObject> = Field extends {
+    readonly value: infer Value;
+} ? Value : 'string';
+type InferStaticSearchValue<Value> = Value extends 'string' ? string : Value extends 'number' ? number : Value extends 'int' ? number : Value extends 'boolean' ? boolean : Value extends 'date' | 'date-time' | 'unix-seconds' | 'unix-ms' ? Date : Value extends StaticDateSearchValue ? Date : Value extends StaticEnumSearchValue ? Value['values'][number] : never;
+type IsOptionalStaticSearchField<Field> = Field extends StaticSearchFieldObject ? 'default' extends keyof Field ? false : Field['optional'] extends true ? true : false : false;
+type IsRequiredStaticSearchBuildField<Field> = Field extends StaticSearchFieldObject ? 'default' extends keyof Field ? false : Field['optional'] extends true ? false : true : true;
+type Simplify<Value> = {
+    readonly [Key in keyof Value]: Value[Key];
+} & {};
+export {};

package/dist/static/create-static-search-schema.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeSearchSchema } from '../search/contracts.js';
+import type { StaticSearchDescriptor } from './contracts.js';
+export declare function createStaticSearchSchema(descriptor: StaticSearchDescriptor): RuntimeSearchSchema;

package/dist/static/normalize-static-search-default.d.ts

@@ -0,0 +1,2 @@
+import type { StaticSearchValue } from './contracts.js';
+export declare function normalizeStaticSearchDefault(fieldType: 'one' | 'many', valueDescriptor: StaticSearchValue, defaultValue: unknown, path: readonly string[]): unknown;

package/dist/static/static-search-field-kind.d.ts

@@ -0,0 +1,4 @@
+import type { StaticSearchField, StaticSearchFieldObject, StaticSearchValue } from './contracts.js';
+export declare function isStaticSearchFieldObject(field: StaticSearchField): field is StaticSearchFieldObject;
+export declare function normalizeStaticSearchFieldValue(field: StaticSearchField): StaticSearchValue;
+export declare function normalizeStaticSearchFieldType(input: unknown, path: readonly string[]): 'one' | 'many';

package/dist/static.d.ts

@@ -0,0 +1,7 @@
+export * from './url/path-constraints.js';
+export { createConstraint } from '@cookbook/pathkit/constraints';
+export type { ConstraintValidation } from '@cookbook/pathkit';
+export * from './static/compile-static-hash.js';
+export * from './static/compile-static-search.js';
+export * from './static/compile-static-url.js';
+export * from './static/contracts.js';