angular-odata 0.99.2 → 0.99.5

package/lib/models/collection.d.ts

@@ -110,8 +110,10 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     [Symbol.iterator](): {
         next(): IteratorResult<M>;
     };
-    filter(predicate: (m: M, index: number) => boolean): M[];
-    find(predicate: (m: M, index: number) => boolean): M | undefined;
+    filter(predicate: (value: M, index: number, array: M[]) => unknown, thisArg?: any): M[];
+    map<U>(callbackfn: (value: M, index: number, array: M[]) => U, thisArg?: any): U[];
+    find(predicate: (value: M, index: number, obj: M[]) => unknown, thisArg?: any): M | undefined;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: M, currentIndex: number, array: M[]) => U, initialValue: U): U;
     first(): M | undefined;
     last(): M | undefined;
     next(model: M): M | undefined;

package/lib/models/options.d.ts

@@ -7,13 +7,6 @@ import type { ODataModel } from './model';
 export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
 export declare class ODataModelEvent<T> {
     name: ODataModelEventType;
-    bubbling: boolean;
-    model?: ODataModel<T>;
-    collection?: ODataCollection<T, ODataModel<T>>;
-    chain: [
-        ODataModel<any> | ODataCollection<any, ODataModel<any>>,
-        string | number | null
-    ][];
     value?: any;
     previous?: any;
     options?: any;
@@ -25,10 +18,19 @@ export declare class ODataModelEvent<T> {
         value?: any;
         options?: any;
     });
+    bubbling: boolean;
     stopPropagation(): void;
+    chain: [
+        ODataModel<any> | ODataCollection<any, ODataModel<any>>,
+        string | number | null
+    ][];
     push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, track: string | number): void;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     get path(): string;
+    model?: ODataModel<T>;
+    get currentModel(): ODataModel<any> | undefined;
+    collection?: ODataCollection<T, ODataModel<T>>;
+    get currentCollection(): ODataCollection<any, ODataModel<any>> | undefined;
 }
 export declare const BUBBLING: string[];
 export declare const INCLUDE_SHALLOW: {

package/lib/resources/query/builder.d.ts

@@ -32,6 +32,7 @@ export declare type ExpandOptions<T> = {
     filter?: Filter<T>;
     orderBy?: OrderBy<T>;
     top?: number;
+    skip?: number;
     levels?: number | 'max';
     count?: boolean | Filter<T>;
     expand?: Expand<T>;

package/lib/resources/query/expressions/base.d.ts

@@ -11,6 +11,7 @@ export declare abstract class Expression<T> implements Renderable {
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    abstract clone(): Expression<T>;
     children(): Renderable[];
     length(): number;
     toJSON(): {

package/lib/resources/query/expressions/compute.d.ts

@@ -9,15 +9,16 @@ export declare class ComputeExpression<T> extends Expression<T> {
     });
     static e<T>(): ComputeExpression<T>;
     static s<T extends object>(): T;
-    static compute<T extends object>(opts: (e: {
+    static compute<T extends object>(opts: (builder: {
         s: T;
         e: () => ComputeExpression<T>;
-    }) => ComputeExpression<T>): ComputeExpression<T>;
+    }, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): ComputeExpression<unknown>;
     private _add;
     field<T extends object>(name: string, opts: (e: {
         o: ODataOperators<T>;

package/lib/resources/query/expressions/expand.d.ts

@@ -1,9 +1,16 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
-import { Renderable } from './syntax';
+import { FilterConnector, FilterExpression } from './filter';
+import { OrderByExpression } from './orderby';
+import { SearchConnector, SearchExpression } from './search';
+import { SelectExpression } from './select';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare class ExpandField<T> implements Renderable {
-    protected field: Renderable;
-    constructor(field: Renderable);
+    protected field: any;
+    private values;
+    constructor(field: any, values?: {
+        [name: string]: any;
+    });
     get [Symbol.toStringTag](): string;
     toJSON(): {
         field: any;
@@ -13,12 +20,32 @@ export declare class ExpandField<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
-    select(): void;
-    filter(): void;
-    levels(): void;
-    orderBy(): void;
-    top(): void;
-    skip(): void;
+    clone(): ExpandField<unknown>;
+    select<T extends object>(opts: (builder: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    expand<T extends object>(opts: (builder: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
+    filter<T extends object>(opts: (builder: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>): any;
+    search<T extends object>(opts: (builder: {
+        e: (connector?: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): any;
+    orderBy<T extends object>(opts: (builder: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
+    skip(n: number): any;
+    top(n: number): any;
+    levels(n: number | 'max'): any;
+    private option;
 }
 export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
@@ -26,15 +53,16 @@ export declare class ExpandExpression<T> extends Expression<T> {
     });
     static e<T>(): ExpandExpression<T>;
     static s<T extends object>(): T;
-    static expand<T extends object>(opts: (e: {
+    static expand<T extends object>(opts: (builder: {
         s: T;
         e: () => ExpandExpression<T>;
-    }) => ExpandExpression<T>): ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): ExpandExpression<unknown>;
     private _add;
-    field<T extends object>(field: any, opts?: (e: ExpandField<keyof T>) => void): ExpandExpression<T>;
+    field<F>(field: F, opts?: (e: ExpandField<F>) => void): ExpandExpression<F>;
 }

package/lib/resources/query/expressions/filter.d.ts

@@ -2,7 +2,7 @@ import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare type FilterConnector = 'and' | 'or';
-export declare class FilterExpression<T> extends Expression<T> {
+export declare class FilterExpression<F> extends Expression<F> {
     private _connector;
     private _negated;
     constructor({ children, connector, negated, }?: {
@@ -12,12 +12,12 @@ export declare class FilterExpression<T> extends Expression<T> {
     });
     static s<T extends object>(): T;
     static e<T>(connector?: FilterConnector): FilterExpression<T>;
-    static filter<T extends object>(opts: (e: {
+    static filter<T extends object>(opts: (builder: {
         s: T;
         e: (connector?: FilterConnector) => FilterExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => FilterExpression<T>): FilterExpression<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJSON(): {
         children: any[];
         connector: FilterConnector;
@@ -30,29 +30,30 @@ export declare class FilterExpression<T> extends Expression<T> {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): FilterExpression<unknown>;
     private _add;
-    or(exp: FilterExpression<T>): FilterExpression<T>;
-    and(exp: FilterExpression<T>): FilterExpression<T>;
-    not(exp: FilterExpression<T>): FilterExpression<T>;
-    eq(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    ne(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    gt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    ge(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    lt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    le(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    has(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    in(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    contains(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
-    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    or(exp: FilterExpression<F>): FilterExpression<F>;
+    and(exp: FilterExpression<F>): FilterExpression<F>;
+    not(exp: FilterExpression<F>): FilterExpression<F>;
+    eq(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    ne(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    gt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    ge(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    lt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    le(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    has(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    in(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    contains(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
     any<N extends object>(left: N[], opts: (e: {
         s: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
-    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     all<N extends object>(left: N[], opts: (e: {
         s: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
-    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
-    isof(type: string): FilterExpression<T>;
-    isof(left: T, type: string): FilterExpression<T>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
+    isof(type: string): FilterExpression<F>;
+    isof(left: F, type: string): FilterExpression<F>;
 }

package/lib/resources/query/expressions/orderby.d.ts

@@ -15,6 +15,7 @@ export declare class OrderByField implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): OrderByField;
 }
 export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
@@ -22,16 +23,17 @@ export declare class OrderByExpression<T> extends Expression<T> {
     });
     static e<T>(): OrderByExpression<T>;
     static s<T extends object>(): T;
-    static orderBy<T extends object>(opts: (e: {
+    static orderBy<T extends object>(opts: (builder: {
         s: T;
         e: () => OrderByExpression<T>;
-    }) => OrderByExpression<T>): OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): OrderByExpression<unknown>;
     ascending(field: any): OrderByExpression<T>;
     descending(field: any): OrderByExpression<T>;
 }

package/lib/resources/query/expressions/search.d.ts

@@ -7,6 +7,7 @@ export declare class SearchTerm implements Renderable {
     constructor(value: string);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         value: string;
     };
     render({ aliases, escape, prefix, }: {
@@ -14,6 +15,7 @@ export declare class SearchTerm implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): SearchTerm;
 }
 export declare class SearchExpression<T> extends Expression<T> {
     private _connector;
@@ -24,15 +26,16 @@ export declare class SearchExpression<T> extends Expression<T> {
         negated?: boolean;
     });
     static e<T>(connector?: SearchConnector): SearchExpression<T>;
-    static search<T extends object>(opts: (e: {
+    static search<T extends object>(opts: (builder: {
         e: (connector?: SearchConnector) => SearchExpression<T>;
-    }) => SearchExpression<T>): SearchExpression<T>;
+    }, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): SearchExpression<unknown>;
     toJSON(): {
         children: any[];
         connector: SearchConnector;

package/lib/resources/query/expressions/select.d.ts

@@ -7,15 +7,16 @@ export declare class SelectExpression<T> extends Expression<T> {
     });
     static e<T>(): SelectExpression<T>;
     static s<T extends object>(): T;
-    static select<T extends object>(opts: (e: {
+    static select<T extends object>(builder: (b: {
         s: T;
         e: () => SelectExpression<T>;
-    }) => SelectExpression<T>): SelectExpression<T>;
+    }, c?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;
         prefix?: string | undefined;
     }): string;
+    clone(): SelectExpression<unknown>;
     private _add;
     field(field: any): SelectExpression<T>;
 }

package/lib/resources/query/expressions/syntax.d.ts

@@ -7,12 +7,14 @@ export interface Renderable {
     }): string;
     toString(): string;
     toJSON(): any;
+    clone(): any;
 }
 export declare class Field<T extends object> implements ProxyHandler<T> {
     name: string;
     constructor(name?: string);
-    static factory<T extends object>(): T;
-    get(target: T, p: string | symbol): any;
+    static factory<T extends object>(name?: string): T;
+    get(target: T, key: string | symbol): any;
+    has(target: T, key: string): any;
 }
 export declare function render(value: any, { aliases, normalize, escape, prefix, }?: {
     aliases?: QueryCustomType[];
@@ -28,6 +30,7 @@ export declare class Function<T> implements Renderable {
     constructor(name: string, values: any[], normalize?: boolean, escape?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         name: string;
         values: any[];
         normalize: boolean;
@@ -37,6 +40,7 @@ export declare class Function<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Function<T>;
 }
 export declare class StringAndCollectionFunctions<T> {
     concat(field: any, value: any, normalize?: boolean): Function<T>;
@@ -97,6 +101,7 @@ export declare class Operator<T> implements Renderable {
     constructor(op: string, values: any[], normalize?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         op: string;
         values: any[];
         normalize: boolean;
@@ -106,6 +111,7 @@ export declare class Operator<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Operator<unknown>;
 }
 export declare class LogicalOperators<T> {
     eq(left: any, right: any, normalize?: boolean): Operator<unknown>;
@@ -131,6 +137,7 @@ export declare class Grouping<T> implements Renderable {
     constructor(group: Renderable);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         group: any;
     };
     render({ aliases, escape, prefix, }: {
@@ -138,6 +145,7 @@ export declare class Grouping<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Grouping<unknown>;
 }
 export declare class Lambda<T> implements Renderable {
     protected op: string;
@@ -146,6 +154,7 @@ export declare class Lambda<T> implements Renderable {
     constructor(op: string, values: any[], alias?: string | undefined);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         op: string;
         values: any[];
         alias: string | undefined;
@@ -155,6 +164,7 @@ export declare class Lambda<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Lambda<unknown>;
 }
 export declare class LambdaOperators<T> {
     any(field: T, value: any, alias?: string): Lambda<unknown>;

package/lib/resources/query/handlers.d.ts

@@ -39,27 +39,27 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The alias
      */
     alias(value: any, name?: string): import("./builder").QueryCustomType;
-    select(opts: (e: {
+    select(opts: (builder: {
         s: T;
         e: () => SelectExpression<T>;
-    }) => SelectExpression<T>): SelectExpression<T>;
+    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
-    expand(opts: (e: {
+    expand(opts: (builder: {
         s: T;
         e: () => ExpandExpression<T>;
-    }) => ExpandExpression<T>): ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
      */
-    compute(opts: (e: {
+    compute(opts: (builder: {
         s: T;
         e: () => ComputeExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => ComputeExpression<T>): ComputeExpression<T>;
+    }, current?: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): ODataQueryOptionHandler<T>;
     /**
@@ -69,23 +69,23 @@ export declare class ODataQueryOptionsHandler<T> {
     format(): ODataQueryOptionHandler<T>;
     transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
     transform(): ODataQueryOptionHandler<T>;
-    search(opts: (e: {
+    search(opts: (builder: {
         e: (connector: SearchConnector) => SearchExpression<T>;
-    }) => SearchExpression<T>): SearchExpression<T>;
+    }, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
-    filter(opts: (e: {
+    filter(opts: (builder: {
         s: T;
         e: (connector?: FilterConnector) => FilterExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => FilterExpression<T>): FilterExpression<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
-    orderBy(opts: (e: {
+    orderBy(opts: (builder: {
         s: T;
         e: () => OrderByExpression<T>;
-    }) => OrderByExpression<T>): OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
     orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
     orderBy(): ODataQueryOptionHandler<T>;
     top(opts: number): ODataQueryOptionHandler<T>;

package/lib/resources/query/options.d.ts

@@ -1,22 +1,24 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { Expression } from './expressions';
+import { Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
+import { ExpandExpression } from './expressions/expand';
+import { SelectExpression } from './expressions/select';
 import { ODataQueryOptionHandler } from './handlers';
 export declare type ODataQueryArguments<T> = {
-    [QueryOptionNames.select]?: Select<T>;
-    [QueryOptionNames.filter]?: Filter<T>;
-    [QueryOptionNames.search]?: string;
+    [QueryOptionNames.select]?: Select<T> | SelectExpression<T>;
+    [QueryOptionNames.filter]?: Filter<T> | FilterExpression<T>;
+    [QueryOptionNames.search]?: string | SearchExpression<T>;
     [QueryOptionNames.compute]?: string;
     [QueryOptionNames.transform]?: Transform<T>;
-    [QueryOptionNames.orderBy]?: OrderBy<T>;
+    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T>;
     [QueryOptionNames.top]?: number;
     [QueryOptionNames.skip]?: number;
     [QueryOptionNames.skiptoken]?: string;
-    [QueryOptionNames.expand]?: Expand<T>;
+    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T>;
     [QueryOptionNames.format]?: string;
 };
 export declare class ODataQueryOptions<T> {
-    options: {
+    values: {
         [name: string]: any;
     };
     constructor(options?: {
@@ -29,7 +31,7 @@ export declare class ODataQueryOptions<T> {
     toJSON(): {};
     toQueryArguments(): ODataQueryArguments<T>;
     clone<O>(): ODataQueryOptions<O>;
-    expression(name: QueryOptionNames, exp: Expression<T>): Expression<T>;
+    expression(name: QueryOptionNames, exp?: Expression<T>): any;
     option<O>(name: QueryOptionNames, opts?: O): ODataQueryOptionHandler<O>;
     has(name: QueryOptionNames): boolean;
     remove(...names: QueryOptionNames[]): void;

package/lib/schema/enum-type.d.ts

@@ -28,6 +28,12 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
      * @returns The field with the given value
      */
     findFieldByValue(value: number): ODataEnumTypeFieldParser | undefined;
+    /**
+     * Find a fields by flag.
+     * @param value The value of the field
+     * @returns The fields with the given flag
+     */
+    findFieldsByValue(value: number): ODataEnumTypeFieldParser[];
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value

package/lib/types.d.ts

@@ -30,6 +30,7 @@ export declare enum QueryOptionNames {
     skip = "skip",
     skiptoken = "skiptoken",
     format = "format",
+    levels = "levels",
     count = "count"
 }
 export interface Options {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.99.2",
+  "version": "0.99.5",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {