@opra/client 0.11.2 → 0.11.4

package/typings/common/schema/implementation/query/collection-update-query.d.ts

@@ -0,0 +1,19 @@
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionUpdateQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class CollectionUpdateQuery {
+    readonly resource: CollectionResourceInfo;
+    data: any;
+    readonly kind = "CollectionUpdateQuery";
+    readonly method = "update";
+    readonly operation = "update";
+    keyValue: any;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    constructor(resource: CollectionResourceInfo, keyValue: any, data: any, options?: CollectionUpdateQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/field-get-query.d.ts

@@ -0,0 +1,30 @@
+import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import { ComplexType, Field } from '../data-type/complex-type.js';
+import type { DataType } from '../data-type/data-type.js';
+import type { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
+import type { CollectionGetQuery } from './collection-get-query.js';
+import type { SingletonGetQuery } from './singleton-get-query.js';
+export declare type FieldGetQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    castingType?: ComplexType;
+};
+export declare class FieldGetQuery implements IChildFieldQuery {
+    readonly parent: CollectionGetQuery | SingletonGetQuery | FieldGetQuery;
+    readonly resource: CollectionResourceInfo | SingletonResourceInfo;
+    readonly kind = "FieldGetQuery";
+    readonly method = "get";
+    readonly operation = "read";
+    readonly fieldName: string;
+    readonly field?: Field;
+    readonly path: string;
+    readonly dataType: DataType;
+    readonly parentType: ComplexType;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    child?: FieldGetQuery;
+    constructor(parent: CollectionGetQuery | SingletonGetQuery | FieldGetQuery, fieldName: string, options?: FieldGetQueryOptions);
+}

package/typings/common/schema/implementation/query/index.d.ts

@@ -0,0 +1,27 @@
+import { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import { CollectionCountQuery } from './collection-count-query.js';
+import { CollectionCreateQuery } from './collection-create-query.js';
+import { CollectionDeleteManyQuery } from './collection-delete-many-query.js';
+import { CollectionDeleteQuery } from './collection-delete-query.js';
+import { CollectionGetQuery } from './collection-get-query.js';
+import { CollectionSearchQuery } from './collection-search-query.js';
+import { CollectionUpdateManyQuery } from './collection-update-many-query.js';
+import { CollectionUpdateQuery } from './collection-update-query.js';
+import { FieldGetQuery } from './field-get-query.js';
+import { SingletonGetQuery } from './singleton-get-query.js';
+export * from './collection-create-query.js';
+export * from './collection-count-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-delete-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-get-query.js';
+export * from './field-get-query.js';
+export * from './singleton-get-query.js';
+export * from './collection-search-query.js';
+export * from './collection-update-many-query.js';
+export * from './collection-update-query.js';
+export declare type CollectionQuery = CollectionCountQuery | CollectionCreateQuery | CollectionDeleteManyQuery | CollectionDeleteQuery | CollectionGetQuery | CollectionSearchQuery | CollectionUpdateManyQuery | CollectionUpdateQuery;
+export declare type FieldQuery = FieldGetQuery;
+export declare type SingletonQuery = SingletonGetQuery;
+export declare type OpraQuery = CollectionQuery | SingletonQuery | FieldQuery;
+export declare function isChildFieldQuery(query: any): query is IChildFieldQuery;

package/typings/common/schema/implementation/query/singleton-get-query.d.ts

@@ -0,0 +1,20 @@
+import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
+import type { FieldGetQuery } from './field-get-query.js';
+export declare type SingletonGetQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class SingletonGetQuery implements IChildFieldQuery {
+    readonly resource: SingletonResourceInfo;
+    readonly kind = "SingletonGetQuery";
+    readonly method = "get";
+    readonly operation = "read";
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    child?: FieldGetQuery;
+    constructor(resource: SingletonResourceInfo, options?: SingletonGetQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/resource/collection-resource-info.d.ts

@@ -0,0 +1,19 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import type { OpraDocument } from '../opra-document';
+import { ResourceInfo } from './resource-info.js';
+export declare class CollectionResourceInfo extends ResourceInfo {
+    readonly metadata: OpraSchema.CollectionResource;
+    readonly dataType: ComplexType;
+    constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.CollectionResource);
+    get keyFields(): string[];
+    get create(): OpraSchema.CreateMethodResolver | undefined;
+    get count(): OpraSchema.MethodResolver | undefined;
+    get delete(): OpraSchema.MethodResolver | undefined;
+    get deleteMany(): OpraSchema.DeleteManyMethodResolver | undefined;
+    get get(): OpraSchema.GetMethodResolver | undefined;
+    get update(): OpraSchema.UpdateMethodResolver | undefined;
+    get updateMany(): OpraSchema.UpdateManyMethodResolver | undefined;
+    get search(): OpraSchema.SearchMethodResolver | undefined;
+    getSchema(jsonOnly?: boolean): OpraSchema.CollectionResource;
+}

package/typings/common/schema/implementation/resource/container-resource-info.d.ts

@@ -0,0 +1,13 @@
+import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import type { OpraDocument } from '../opra-document.js';
+import { CollectionResourceInfo } from './collection-resource-info.js';
+import { ResourceInfo } from './resource-info.js';
+import { SingletonResourceInfo } from './singleton-resource-info.js';
+export declare class ContainerResourceInfo extends ResourceInfo implements IResourceContainer {
+    readonly metadata: OpraSchema.ContainerResource;
+    constructor(service: OpraDocument, name: string, metadata: OpraSchema.ContainerResource);
+    getResource<T extends ResourceInfo>(name: string): T;
+    getCollectionResource(name: string): CollectionResourceInfo;
+    getSingletonResource(name: string): SingletonResourceInfo;
+}

package/typings/common/schema/implementation/resource/resource-info.d.ts

@@ -0,0 +1,17 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { nodeInspectCustom } from '../../utils/inspect.util.js';
+import type { OpraDocument } from '../opra-document.js';
+export declare abstract class ResourceInfo {
+    readonly metadata: OpraSchema.Resource;
+    readonly document: OpraDocument;
+    readonly name: string;
+    protected path: string;
+    protected constructor(document: OpraDocument, name: string, metadata: OpraSchema.Resource);
+    get instance(): {} | undefined;
+    get kind(): OpraSchema.ResourceKind;
+    get description(): string | undefined;
+    toString(): string;
+    validateQueryOptions(): any;
+    getSchema(jsonOnly?: boolean): OpraSchema.Resource;
+    [nodeInspectCustom](): string;
+}

package/typings/common/schema/implementation/resource/singleton-resource-info.d.ts

@@ -0,0 +1,14 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import type { OpraDocument } from '../opra-document.js';
+import { ResourceInfo } from './resource-info.js';
+export declare class SingletonResourceInfo extends ResourceInfo {
+    readonly metadata: OpraSchema.SingletonResource;
+    readonly dataType: ComplexType;
+    constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.SingletonResource);
+    get create(): OpraSchema.CreateMethodResolver | undefined;
+    get delete(): OpraSchema.MethodResolver | undefined;
+    get get(): OpraSchema.GetMethodResolver | undefined;
+    get update(): OpraSchema.UpdateMethodResolver | undefined;
+    getSchema(jsonOnly?: boolean): OpraSchema.SingletonResource;
+}

package/typings/common/schema/implementation/schema-builder/extract-resource-metadata.util.d.ts

@@ -0,0 +1,3 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { Named } from '../../types.js';
+export declare function extractResourceSchema(instance: object): Promise<Named<OpraSchema.Resource>>;

package/typings/common/schema/implementation/schema-builder/extract-type-metadata.util.d.ts

@@ -0,0 +1,4 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { Named } from '../../types.js';
+export declare function extractDataTypeSchema(ctor: Type | Function): Promise<Named<OpraSchema.DataType>>;

package/typings/common/schema/index.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+export * from './constants.js';
+export * from './types.js';
+export * from './opra-schema.definition.js';
+export * from './decorators/opr-complex-type.decorator.js';
+export * from './decorators/opr-field.decorator.js';
+export * from './decorators/opr-collection-resource.decorator.js';
+export * from './decorators/opr-singleton-resource.decorator.js';
+export * from './decorators/opr-resolver.decorator.js';
+export * from './interfaces/resource-container.interface.js';
+export * from './implementation/document-builder.js';
+export * from './implementation/opra-document.js';
+export * from './implementation/data-type/data-type.js';
+export * from './implementation/data-type/complex-type.js';
+export * from './implementation/data-type/simple-type.js';
+export * from './implementation/data-type/union-type.js';
+export * from './implementation/resource/resource-info.js';
+export * from './implementation/resource/container-resource-info.js';
+export * from './implementation/resource/collection-resource-info.js';
+export * from './implementation/resource/singleton-resource-info.js';
+export * from './implementation/query/index.js';
+export * from './type-helpers/mixin-type.helper.js';
+export * from './type-helpers/extend-type.helper.js';
+export * from './implementation/schema-builder/extract-type-metadata.util.js';
+export * from './implementation/schema-builder/extract-resource-metadata.util.js';

package/typings/common/schema/interfaces/child-field-query.interface.d.ts

@@ -0,0 +1,4 @@
+import type { FieldGetQueryOptions } from '../implementation/query/index.js';
+export interface IChildFieldQuery {
+    child?: FieldGetQueryOptions;
+}

package/typings/common/schema/interfaces/data-type.metadata.d.ts

@@ -0,0 +1,18 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { TypeThunkAsync } from '../types.js';
+export declare type SimpleTypeMetadata = OpraSchema.SimpleType & {
+    name: string;
+};
+export declare type ComplexTypeMetadata = StrictOmit<OpraSchema.ComplexType, 'fields' | 'extends'> & {
+    name: string;
+    extends?: ComplexTypeExtendingMetadata[];
+    fields?: Record<string, FieldMetadata>;
+};
+export declare type FieldMetadata = StrictOmit<OpraSchema.Field, 'type'> & {
+    type?: string | TypeThunkAsync | (string | TypeThunkAsync)[];
+};
+declare type ComplexTypeExtendingMetadata = StrictOmit<OpraSchema.ComplexTypeExtendingInfo, 'type'> & {
+    type: string | Type;
+};
+export {};

package/typings/common/schema/interfaces/resource-container.interface.d.ts

@@ -0,0 +1,8 @@
+import { CollectionResourceInfo } from '../implementation/resource/collection-resource-info.js';
+import { ResourceInfo } from '../implementation/resource/resource-info.js';
+import { SingletonResourceInfo } from '../implementation/resource/singleton-resource-info.js';
+export interface IResourceContainer {
+    getResource<T extends ResourceInfo>(name: string): T;
+    getCollectionResource(name: string): CollectionResourceInfo;
+    getSingletonResource(name: string): SingletonResourceInfo;
+}

package/typings/common/schema/interfaces/resource.metadata.d.ts

@@ -0,0 +1,18 @@
+import { PartialSome, StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { TypeThunkAsync } from '../types.js';
+export declare type CollectionResourceMetadata = PartialSome<StrictOmit<OpraSchema.CollectionResource, 'type'>, 'keyFields'> & {
+    type: TypeThunkAsync | string;
+    name: string;
+};
+export declare type SingletonResourceMetadata = StrictOmit<OpraSchema.SingletonResource, 'type'> & {
+    type: TypeThunkAsync | string;
+    name: string;
+};
+export declare type ICreateResolverMetadata = StrictOmit<OpraSchema.CreateMethodResolver, 'handler'>;
+export declare type IDeleteResolverMetadata = StrictOmit<OpraSchema.DeleteMethodResolver, 'handler'>;
+export declare type IDeleteManyResolverMetadata = StrictOmit<OpraSchema.DeleteManyMethodResolver, 'handler'>;
+export declare type IGetResolverMetadata = StrictOmit<OpraSchema.GetMethodResolver, 'handler'>;
+export declare type IUpdateResolverMetadata = StrictOmit<OpraSchema.UpdateMethodResolver, 'handler'>;
+export declare type IUpdateManyResolverMetadata = StrictOmit<OpraSchema.UpdateManyMethodResolver, 'handler'>;
+export declare type ISearchResolverMetadata = StrictOmit<OpraSchema.SearchMethodResolver, 'handler'>;

package/typings/common/schema/opra-schema.definition.d.ts

@@ -0,0 +1,178 @@
+import { Type } from 'ts-gems';
+import { ComparisonOperator } from '../filter/index.js';
+export declare namespace OpraSchema {
+    /**
+     * *** === Constants === ***
+     */
+    export const Version = "1.0";
+    /**
+     * *** === Type definitions === ***
+     */
+    export type Extensible<T = any> = {
+        [key: `$${string}`]: T;
+    };
+    export type ResourceKind = 'ContainerResource' | 'CollectionResource' | 'SingletonResource';
+    export type DataTypeKind = 'SimpleType' | 'ComplexType' | 'UnionType';
+    export type SingletonMethod = 'get' | 'create' | 'update' | 'delete';
+    export type CollectionMethod = SingletonMethod | 'search' | 'count' | 'updateMany' | 'deleteMany';
+    /**
+     * *** === Document related === ***
+     */
+    export interface Document {
+        version: string;
+        info: DocumentInfo;
+        references?: Record<string, Reference>;
+        types?: Record<string, DataType>;
+        resources?: Record<string, Resource>;
+        servers?: ServerInfo[];
+    }
+    export type ServerInfo = Extensible & {
+        url: string;
+        description?: string;
+    };
+    export type Reference = Extensible & {
+        url?: string;
+        document?: Document;
+    };
+    export type DocumentInfo = Extensible & {
+        title: string;
+        version: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: ContactPerson[];
+        license?: LicenseInfo;
+    };
+    export type ContactPerson = Extensible & {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    export type LicenseInfo = Extensible & {
+        name: string;
+        url?: string;
+        content?: string;
+    };
+    /**
+     * *** === Data Type related === ***
+     */
+    export type DataType = ComplexType | SimpleType | UnionType;
+    export type BaseDataType = {
+        kind: DataTypeKind;
+        description?: string;
+        ctor?: Type;
+        parse?: (v: any) => any;
+        serialize?: (v: any) => any;
+    };
+    export interface SimpleType extends BaseDataType {
+        kind: 'SimpleType';
+    }
+    export interface UnionType extends BaseDataType {
+        kind: 'UnionType';
+        types: DataType[];
+    }
+    export interface ComplexType extends BaseDataType {
+        kind: 'ComplexType';
+        description?: string;
+        abstract?: boolean;
+        extends?: ComplexTypeExtendingInfo[];
+        fields?: Record<string, Field>;
+        additionalFields?: boolean | string | Pick<Field, 'type' | 'format' | 'isArray' | 'enum'>;
+    }
+    export interface ComplexTypeExtendingInfo {
+        type: string;
+        pick?: string[];
+        omit?: string[];
+    }
+    export type Field = Extensible & {
+        type: string;
+        description?: string;
+        required?: boolean;
+        isArray?: boolean;
+        format?: string;
+        default?: any;
+        fixed?: string | number;
+        enum?: string | string[] | Record<string, string>;
+        enumName?: string;
+        examples?: any[] | Record<string, any>;
+        deprecated?: boolean | string;
+        /**
+         * If true, this property will not be included in results by default.
+         * The client side should include the property name in the "include" query parameter.
+         */
+        exclusive?: boolean;
+    };
+    /**
+     * *** === Resource related === ***
+     */
+    export type Resource = ContainerResource | CollectionResource | SingletonResource;
+    export interface BaseResource {
+        kind: ResourceKind;
+        description?: string;
+        instance?: {};
+    }
+    export interface CollectionResource extends BaseResource {
+        kind: 'CollectionResource';
+        type: string;
+        keyFields: string | string[];
+        create?: CreateMethodResolver;
+        count?: CountMethodResolver;
+        delete?: DeleteMethodResolver;
+        deleteMany?: DeleteManyMethodResolver;
+        get?: GetMethodResolver;
+        update?: UpdateMethodResolver;
+        updateMany?: UpdateManyMethodResolver;
+        search?: SearchMethodResolver;
+    }
+    export interface SingletonResource extends BaseResource {
+        kind: 'SingletonResource';
+        type: string;
+        create?: CreateMethodResolver;
+        get?: GetMethodResolver;
+        update?: UpdateMethodResolver;
+        delete?: DeleteMethodResolver;
+    }
+    export interface ContainerResource extends BaseResource {
+        kind: 'ContainerResource';
+        resources: Resource[];
+    }
+    export type MethodResolver = {
+        handler?: Function;
+    };
+    type MethodResolverInputOptions = {
+        inputPick?: string[];
+        inputOmit?: string[];
+    };
+    type MethodResolverOutputOptions = {
+        outputPick?: string[];
+        outputOmit?: string[];
+    };
+    type MethodResolverFilterOptions = {
+        filters?: {
+            field: string;
+            operators?: ComparisonOperator[];
+        }[];
+    };
+    export type CreateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
+    export type CountMethodResolver = MethodResolver & {};
+    export type DeleteMethodResolver = MethodResolver & {};
+    export type DeleteManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
+    export type GetMethodResolver = MethodResolver & MethodResolverOutputOptions;
+    export type UpdateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
+    export type UpdateManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
+    export type SearchMethodResolver = MethodResolver & MethodResolverOutputOptions & {
+        sortFields?: string[];
+        defaultSort?: string[];
+    } & MethodResolverFilterOptions;
+    /**
+     * *** === Type Guards === ***
+     */
+    export function isDataType(obj: any): obj is DataType;
+    export function isComplexType(obj: any): obj is ComplexType;
+    export function isSimpleType(obj: any): obj is SimpleType;
+    export function isUnionTypee(obj: any): obj is UnionType;
+    export function isResource(obj: any): obj is Resource;
+    export function isCollectionResource(obj: any): obj is CollectionResource;
+    export function isSingletonResource(obj: any): obj is SingletonResource;
+    export function isContainerResource(obj: any): obj is ContainerResource;
+    export {};
+}

package/typings/common/schema/type-helpers/extend-type.helper.d.ts

@@ -0,0 +1,3 @@
+import { Class } from 'ts-gems';
+export declare function PickType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Pick<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;
+export declare function OmitType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Omit<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;

package/typings/common/schema/type-helpers/mixin-type.helper.d.ts

@@ -0,0 +1,2 @@
+import { Class } from 'ts-gems';
+export declare function MixinType<A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;

package/typings/common/schema/type-helpers/mixin.utils.d.ts

@@ -0,0 +1,3 @@
+import { Type } from 'ts-gems';
+export declare function applyMixins(derivedCtor: any, baseCtor: any, filter?: (k: string) => boolean): void;
+export declare function inheritPropertyInitializers(target: Record<string, any>, sourceClass: Type, isPropertyInherited?: (key: string) => boolean): void;

package/typings/common/schema/types.d.ts

@@ -0,0 +1,14 @@
+import { Builtin, DeepPickWritable, Type } from 'ts-gems';
+export declare type PartialInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
+export declare type PartialOutput<T> = DeepNullablePartial<T>;
+declare type DeepNullablePartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullablePartial<U>> : T extends (infer U)[] ? DeepNullablePartial<U>[] : {
+    [P in keyof T]?: DeepNullablePartial<Exclude<T[P], undefined>> | null;
+};
+export declare type Thunk<T> = T | (() => T);
+export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export declare type TypeThunk<T = any> = Thunk<Type<T>>;
+export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
+export declare type Named<T> = T & {
+    name: string;
+};
+export {};

package/typings/common/schema/utils/class.utils.d.ts

@@ -0,0 +1,2 @@
+import { Type } from 'ts-gems';
+export declare function isConstructor(obj: any): obj is Type;

package/typings/common/schema/utils/clone-object.util.d.ts

@@ -0,0 +1 @@
+export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;

package/typings/common/schema/utils/inspect.util.d.ts

@@ -0,0 +1,4 @@
+export declare const nodeInspectCustom: unique symbol;
+export declare const colorReset = "\u001B[0m";
+export declare const colorFgYellow = "\u001B[33m";
+export declare const colorFgMagenta = "\u001B[35m";

package/typings/common/schema/utils/normalize-field-array.util.d.ts

@@ -0,0 +1,3 @@
+import { ComplexType } from '../implementation/data-type/complex-type.js';
+import type { OpraDocument } from '../implementation/opra-document.js';
+export declare function normalizeFieldArray(document: OpraDocument, dataType: ComplexType | undefined, fields: string[], parentPath?: string): string[];

package/typings/common/schema/utils/path-to-tree.util.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function pathToTree(arr: string[]): ObjectTree | undefined;

package/typings/common/schema/utils/string-compare.util.d.ts

@@ -0,0 +1 @@
+export declare function stringCompare(a: string, b: string): number;

package/typings/common/url/formats/boolean-format.d.ts

@@ -0,0 +1,5 @@
+import { Format } from './format.js';
+export declare class BooleanFormat extends Format {
+    parse(value: string): boolean;
+    stringify(value: any): string;
+}

package/typings/common/url/formats/date-format.d.ts

@@ -0,0 +1,16 @@
+import { Format } from './format.js';
+export interface DateFormatOptions {
+    time?: boolean;
+    timeZone?: boolean;
+    min?: string;
+    max?: string;
+}
+export declare class DateFormat extends Format {
+    time: boolean;
+    timeZone: boolean;
+    min?: string;
+    max?: string;
+    constructor(options?: DateFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/typings/common/url/formats/filter-format.d.ts

@@ -0,0 +1,6 @@
+import { Ast, Expression } from '../../filter/ast/index.js';
+import { Format } from './format.js';
+export declare class FilterFormat extends Format {
+    parse(value: string | Expression): object;
+    stringify(value: Ast): string;
+}

package/typings/common/url/formats/format.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Format {
+    abstract parse(value: string): any;
+    abstract stringify(value: any): string;
+}

package/typings/common/url/formats/integer-format.d.ts

@@ -0,0 +1,9 @@
+import { NumberFormat, NumberFormatOptions } from './number-format.js';
+export interface IntegerFormatOptions extends NumberFormatOptions {
+    enum?: number[];
+}
+export declare class IntegerFormat extends NumberFormat {
+    enum?: number[];
+    constructor(options?: IntegerFormatOptions);
+    parse(value: string): number;
+}

package/typings/common/url/formats/number-format.d.ts

@@ -0,0 +1,12 @@
+import { Format } from './format.js';
+export interface NumberFormatOptions {
+    max?: number;
+    min?: number;
+}
+export declare class NumberFormat extends Format {
+    max?: number;
+    min?: number;
+    constructor(options?: NumberFormatOptions);
+    parse(value: string): number;
+    stringify(value: any): string;
+}

package/typings/common/url/formats/string-format.d.ts

@@ -0,0 +1,14 @@
+import { Format } from './format.js';
+export interface StringFormatOptions {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+}
+export declare class StringFormat extends Format {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+    constructor(options?: StringFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/typings/common/url/index.d.ts

@@ -0,0 +1,5 @@
+export * from './opra-url.js';
+export * from './opra-url-path.js';
+export * from './opra-url-path-component.js';
+export * from './opra-url-search-params.js';
+export * from './utils/path-utils.js';

package/typings/common/url/opra-url-path-component.d.ts

@@ -0,0 +1,15 @@
+declare const nodeInspectCustom: unique symbol;
+export declare type OpraURLPathComponentInit = {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+};
+export declare class OpraURLPathComponent {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+    constructor(init: OpraURLPathComponentInit);
+    toString(): string;
+    [nodeInspectCustom](): any;
+}
+export {};

package/typings/common/url/opra-url-path.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { OpraURLPathComponent, OpraURLPathComponentInit } from './opra-url-path-component.js';
+declare const nodeInspectCustom: unique symbol;
+export declare class OpraURLPath extends EventEmitter {
+    private _entries;
+    constructor(...components: (OpraURLPathComponent | OpraURLPathComponentInit)[]);
+    constructor(init?: string | OpraURLPath | URL | OpraURLPathComponent | OpraURLPathComponentInit);
+    get size(): number;
+    add(component: OpraURLPathComponent | {
+        resource: string;
+        key?: any;
+        typeCast?: string;
+    }): void;
+    add(name: string, key?: any, typeCast?: string): void;
+    clear(): void;
+    get(index: number): OpraURLPathComponent;
+    join(pathString: string): this;
+    entries(): IterableIterator<[OpraURLPathComponent, number]>;
+    values(): IterableIterator<OpraURLPathComponent>;
+    forEach(callback: (name: string, key: any, _this: this) => void): void;
+    getResource(index: number): string | undefined;
+    getKey(index: number): any;
+    toString(): string;
+    [Symbol.iterator](): IterableIterator<[OpraURLPathComponent, number]>;
+    [nodeInspectCustom](): OpraURLPathComponent[];
+    protected _add(component: any, key?: any, typeCast?: string): void;
+    protected _parse(v: string): void;
+}
+export {};