angular-odata 0.131.0 → 0.140.0

package/lib/schema/annotation.d.ts

@@ -1,28 +0,0 @@
-import { ODataAnnotationConfig } from '../types';
-export declare class ODataAnnotation {
-    term: string;
-    string?: string;
-    bool?: boolean;
-    int?: number;
-    permissions?: string[];
-    properties?: string[];
-    constructor(annot: ODataAnnotationConfig);
-}
-export declare class ODataAnnotatable {
-    annotations: ODataAnnotation[];
-    constructor(config: {
-        annotations?: ODataAnnotationConfig[];
-    });
-    /**
-     * Find an annotation inside the annotatable.
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
-    /**
-     * Find an annotation inside the annotatable and return its value.
-     * @param term The term of the annotation to find.
-     * @returns The value of the annotation.
-     */
-    annotatedValue<T>(term: string | RegExp): T | undefined;
-}

package/lib/schema/callable.d.ts

@@ -1,41 +0,0 @@
-import { ODataCallableConfig, ParserOptions } from '../types';
-import { ODataParserSchemaElement } from './element';
-import { ODataCallableParser } from './parsers';
-import { ODataSchema } from './schema';
-export declare class ODataCallable<R> extends ODataParserSchemaElement<R, ODataCallableParser<R>> {
-    entitySetPath?: string;
-    bound?: boolean;
-    composable?: boolean;
-    constructor(config: ODataCallableConfig, schema: ODataSchema);
-    path(): string;
-    configure({ options }: {
-        options: ParserOptions;
-    }): void;
-    /**
-     * Deseialize the given value from the callable.
-     * @param value Value to deserialize
-     * @param options Options for deserialization
-     * @returns Deserialized value
-     */
-    deserialize(value: any, options?: ParserOptions): any;
-    /**
-     * Serialize the given value for the callable.
-     * @param value Value to serialize
-     * @param options Options for serialization
-     * @returns Serialized value
-     */
-    serialize(value: any, options?: ParserOptions): any;
-    /**
-     * Encode the given value for the callable.
-     * @param value Value to encode
-     * @param options Options for encoding
-     * @returns Encoded value
-     */
-    encode(value: any, options?: ParserOptions): any;
-    /**
-     * Returns the binding parameter of the callable.
-     * @returns The binding parameter of the callable.
-     */
-    binding(): import("angular-odata").ODataParameterParser<any> | undefined;
-    returnType(): string | undefined;
-}

package/lib/schema/element.d.ts

@@ -1,52 +0,0 @@
-import { ODataAnnotationConfig, Parser } from '../types';
-import { ODataAnnotatable } from './annotation';
-import { ODataSchema } from './schema';
-export declare class ODataSchemaElement extends ODataAnnotatable {
-    name: string;
-    schema: ODataSchema;
-    constructor(config: {
-        annotations?: ODataAnnotationConfig[];
-        name: string;
-    }, schema: ODataSchema);
-    get api(): import("angular-odata").ODataApi;
-    /**
-     * Create a nicer looking title.
-     * Titleize is meant for creating pretty output.
-     * @param term The term of the annotation to find.
-     * @returns The titleized string.
-     */
-    titleize(term?: string | RegExp): string;
-    /**
-     * Returns a full type of the structured type including the namespace/alias.
-     * @param alias Use the alias of the namespace instead of the namespace.
-     * @returns The string representation of the type.
-     */
-    type({ alias }?: {
-        alias?: boolean;
-    }): string;
-    /**
-     * Returns a boolean indicating if the structured type is of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isTypeOf(element: ODataSchemaElement): boolean;
-    /**
-     * Returns a boolean indicating if the structured type is a subtype of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isSubtypeOf(element: ODataSchemaElement): boolean;
-    /**
-     * Returns a boolean indicating if the structured type is a supertype of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isSupertypeOf(element: ODataSchemaElement): boolean;
-}
-export declare class ODataParserSchemaElement<E, P extends Parser<E>> extends ODataSchemaElement {
-    parser: P;
-    constructor(config: {
-        annotations?: ODataAnnotationConfig[];
-        name: string;
-    }, schema: ODataSchema, parser: P);
-}

package/lib/schema/entity-container.d.ts

@@ -1,10 +0,0 @@
-import { ODataEntityContainerConfig } from '../types';
-import { ODataSchemaElement } from './element';
-import { ODataEntitySet } from './entity-set';
-import { ODataSchema } from './schema';
-import { ODataSingleton } from './singleton';
-export declare class ODataEntityContainer extends ODataSchemaElement {
-    entitySets: ODataEntitySet[];
-    singletons: ODataSingleton[];
-    constructor(config: ODataEntityContainerConfig, schema: ODataSchema);
-}

package/lib/schema/entity-set.d.ts

@@ -1,10 +0,0 @@
-import { ODataEntitySetConfig } from '../types';
-import { ODataSchemaElement } from './element';
-import { ODataSchema } from './schema';
-export declare class ODataEntitySet extends ODataSchemaElement {
-    entityType: string;
-    service: {
-        new (...params: any[]): any;
-    };
-    constructor(config: ODataEntitySetConfig, schema: ODataSchema);
-}

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

@@ -1,55 +0,0 @@
-import { ODataEnumTypeConfig, ParserOptions } from '../types';
-import { ODataParserSchemaElement } from './element';
-import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
-import { ODataSchema } from './schema';
-export declare class ODataEnumType<E> extends ODataParserSchemaElement<E, ODataEnumTypeParser<E>> {
-    members: {
-        [name: string]: number;
-    } | {
-        [value: number]: string;
-    };
-    constructor(config: ODataEnumTypeConfig, schema: ODataSchema);
-    configure({ options }: {
-        options: ParserOptions;
-    }): void;
-    /**
-     * Returns the fields of the enum type.
-     * @returns The fields of the enum type.
-     */
-    fields(namesValue?: string | number): ODataEnumTypeFieldParser[];
-    /**
-     * Find a field by name or value.
-     * @param enu The name or value of the field
-     * @returns The field with the given name or value
-     */
-    field(nameValue: string | number): ODataEnumTypeFieldParser | undefined;
-    /**
-     * Map the fields of the enum type.
-     * @param mapper Function that maps the value to the new value
-     * @returns The fields mapped by the mapper
-     */
-    mapFields<T>(mapper: (field: ODataEnumTypeFieldParser) => T): T[];
-    /**
-     * Deseialize the given value from the enum type.
-     * @param value Value to deserialize
-     * @param options Options for deserialization
-     * @returns Deserialized value
-     */
-    deserialize(value: any, options?: ParserOptions): E;
-    /**
-     * Serialize the given value for the enum type.
-     * @param value Value to serialize
-     * @param options Options for serialization
-     * @returns Serialized value
-     */
-    serialize(value: number, options?: ParserOptions): any;
-    /**
-     * Encode the given value for the enum type.
-     * @param value Value to encode
-     * @param options Options for encoding
-     * @returns Encoded value
-     */
-    encode(value: number, options?: ParserOptions): any;
-    unpack(value: string | number): number[];
-    pack(value: string | number | number[]): number;
-}

package/lib/schema/index.d.ts

@@ -1,8 +0,0 @@
-export * from './schema';
-export * from './entity-container';
-export * from './callable';
-export * from './enum-type';
-export * from './structured-type';
-export * from './entity-set';
-export * from './singleton';
-export * from './parsers';

package/lib/schema/parsers/callable.d.ts

@@ -1,47 +0,0 @@
-import { ODataCallableConfig, ParserOptions, ODataParameterConfig, Parser } from '../../types';
-import { ODataEnumTypeParser } from './enum-type';
-import { ODataStructuredTypeParser } from './structured-type';
-export declare class ODataParameterParser<T> {
-    name: string;
-    type: string;
-    private parser;
-    collection?: boolean;
-    nullable?: boolean;
-    parserOptions?: ParserOptions;
-    constructor(name: string, parameter: ODataParameterConfig);
-    serialize(value: T, options?: ParserOptions): any;
-    encode(value: any, options?: ParserOptions): string;
-    configure({ options, parserForType, }: {
-        options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-    }): void;
-    isEdmType(): boolean;
-    isEnumType(): boolean;
-    enumType(): ODataEnumTypeParser<T>;
-    isStructuredType(): boolean;
-    structuredType(): ODataStructuredTypeParser<T>;
-    field<F>(name: string): import("angular-odata").ODataStructuredTypeFieldParser<F>;
-}
-export declare class ODataCallableParser<R> implements Parser<R> {
-    name: string;
-    namespace: string;
-    alias?: string;
-    return?: {
-        type: string;
-        collection?: boolean;
-    };
-    parser: Parser<any>;
-    parameters: ODataParameterParser<any>[];
-    parserOptions?: ParserOptions;
-    constructor(config: ODataCallableConfig, namespace: string, alias?: string);
-    isTypeOf(type: string): boolean;
-    deserialize(value: any, options?: ParserOptions): R;
-    serialize(params: any, options?: ParserOptions): any;
-    encode(params: any, options?: ParserOptions): any;
-    configure({ options, parserForType, }: {
-        options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-    }): void;
-    binding(): ODataParameterParser<any> | undefined;
-    returnType(): string | undefined;
-}

package/lib/schema/parsers/edm.d.ts

@@ -1,4 +0,0 @@
-import { FieldParser } from '../../types';
-export declare const EDM_PARSERS: {
-    [type: string]: FieldParser<any>;
-};

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

@@ -1,56 +0,0 @@
-import { ODataEnumTypeConfig, ODataEnumTypeFieldConfig, ParserOptions, FieldParser, JsonType } from '../../types';
-import { ODataAnnotatable } from '../annotation';
-export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
-    name: string;
-    value: number;
-    constructor(name: string, field: ODataEnumTypeFieldConfig);
-    titleize(term?: string | RegExp): string;
-}
-export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements FieldParser<E> {
-    name: string;
-    namespace: string;
-    alias?: string;
-    flags?: boolean;
-    members: {
-        [name: string]: number;
-    } | {
-        [value: number]: string;
-    };
-    private _fields;
-    parserOptions?: ParserOptions;
-    constructor(config: ODataEnumTypeConfig, namespace: string, alias?: string);
-    configure({ options }: {
-        options: ParserOptions;
-    }): void;
-    isTypeOf(type: string): boolean;
-    fields(namesValue?: string | number | number[]): ODataEnumTypeFieldParser[];
-    field(nameValue: string | number): ODataEnumTypeFieldParser | undefined;
-    /**
-     * Map the fields of the enum type.
-     * @param mapper Function that maps the value to the new value
-     * @returns The fields mapped by the mapper
-     */
-    mapFields<R>(mapper: (field: ODataEnumTypeFieldParser) => R): R[];
-    deserialize(value: string, options?: ParserOptions): E;
-    serialize(value: number, options?: ParserOptions): string | undefined;
-    encode(value: number, options?: ParserOptions): any;
-    toJsonSchema(): {
-        title: string;
-        type: JsonType;
-        items: {
-            type: JsonType;
-        };
-        enum?: undefined;
-    } | {
-        type: JsonType;
-        enum: number[];
-        title?: undefined;
-        items?: undefined;
-    };
-    validate(value: string | number, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'modify';
-        navigation?: boolean;
-    }): string[] | undefined;
-    unpack(value: string | number): number[];
-    pack(value: string | number | number[]): number;
-}

package/lib/schema/parsers/index.d.ts

@@ -1,4 +0,0 @@
-export * from './edm';
-export * from './enum-type';
-export * from './structured-type';
-export * from './callable';

package/lib/schema/parsers/structured-type.d.ts

@@ -1,172 +0,0 @@
-import { ParserOptions, Parser, ODataStructuredTypeConfig, ODataStructuredTypeFieldConfig, FieldParser, EdmType } from '../../types';
-import { ODataAnnotatable } from '../annotation';
-import { ODataEnumTypeParser } from './enum-type';
-type JsonSchemaSelect<T> = Array<keyof T>;
-type JsonSchemaCustom<T> = {
-    [P in keyof T]?: (schema: any, field: ODataStructuredTypeFieldParser<T[P]>) => any;
-};
-type JsonSchemaExpand<T> = {
-    [P in keyof T]?: JsonSchemaOptions<T[P]>;
-};
-type JsonSchemaRequired<T> = {
-    [P in keyof T]?: boolean;
-};
-export type JsonSchemaOptions<T> = {
-    select?: JsonSchemaSelect<T>;
-    custom?: JsonSchemaCustom<T>;
-    expand?: JsonSchemaExpand<T>;
-    required?: JsonSchemaRequired<T>;
-};
-export declare class ODataEntityTypeKey {
-    name: string;
-    alias?: string;
-    constructor({ name, alias }: {
-        name: string;
-        alias?: string;
-    });
-}
-export declare class ODataReferential {
-    property: string;
-    referencedProperty: string;
-    constructor({ property, referencedProperty, }: {
-        property: string;
-        referencedProperty: string;
-    });
-}
-export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable implements FieldParser<T> {
-    name: string;
-    private structured;
-    type: string | EdmType;
-    private parser;
-    collection: boolean;
-    navigation: boolean;
-    nullable?: boolean;
-    default?: any;
-    maxLength?: number;
-    precision?: number;
-    scale?: number | 'variable';
-    referentials: ODataReferential[];
-    parserOptions?: ParserOptions;
-    constructor(name: string, structured: ODataStructuredTypeParser<any>, field: ODataStructuredTypeFieldConfig);
-    validate(value: any, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'modify';
-        navigation?: boolean;
-    }): {
-        [name: string]: any;
-    } | {
-        [name: string]: any;
-    }[] | string[] | undefined;
-    private parse;
-    deserialize(value: any, options?: ParserOptions): T;
-    private toJson;
-    serialize(value: T, options?: ParserOptions): any;
-    encode(value: T, options?: ParserOptions): string;
-    configure({ options, parserForType, }: {
-        options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-    }): void;
-    toJsonSchema(options?: JsonSchemaOptions<T>): any;
-    isKey(): boolean;
-    hasReferentials(): boolean;
-    isEdmType(): boolean;
-    isEnumType(): boolean;
-    enumType(): ODataEnumTypeParser<T>;
-    isStructuredType(): boolean;
-    structuredType(): ODataStructuredTypeParser<T>;
-    field<F>(name: string): ODataStructuredTypeFieldParser<F>;
-}
-export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable implements Parser<T> {
-    name: string;
-    namespace: string;
-    open: boolean;
-    children: ODataStructuredTypeParser<any>[];
-    alias?: string;
-    base?: string;
-    parent?: ODataStructuredTypeParser<any>;
-    private _keys?;
-    private _fields;
-    parserOptions?: ParserOptions;
-    constructor(config: ODataStructuredTypeConfig, namespace: string, alias?: string);
-    addField<F>(name: string, config: ODataStructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
-    /**
-     * Create a nicer looking title.
-     * Titleize is meant for creating pretty output.
-     * @param term The term of the annotation to find.
-     * @returns The titleized string.
-     */
-    titleize(term?: string | RegExp): string;
-    isTypeOf(type: string): boolean;
-    isSubtypeOf(type: string): boolean;
-    isSupertypeOf(type: string): boolean;
-    isOpenType(): boolean;
-    findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
-    childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;
-    deserialize(value: any, options?: ParserOptions): T;
-    serialize(value: Partial<T>, options?: ParserOptions): any;
-    encode(value: T, options?: ParserOptions): any;
-    configure({ options, parserForType, }: {
-        options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-    }): void;
-    /**
-     * Returns all fields of the structured type.
-     * @param include_navigation Include navigation properties in the result.
-     * @param include_parents Include the parent types in the result.
-     * @returns All fields of the structured type.
-     */
-    fields({ include_navigation, include_parents, }: {
-        include_parents: boolean;
-        include_navigation: boolean;
-    }): ODataStructuredTypeFieldParser<any>[];
-    /**
-     * Returns the keys of the structured type.
-     * @param include_parents Include the parent fields
-     * @returns The keys of the structured type
-     */
-    keys({ include_parents, }: {
-        include_parents: boolean;
-    }): ODataEntityTypeKey[];
-    isEntityType(): boolean;
-    isComplexType(): boolean;
-    /**
-     * Find the field parser for the given field name.
-     * @param name Name of the field
-     * @returns The field parser
-     */
-    field<F>(name: keyof T): ODataStructuredTypeFieldParser<F>;
-    /**
-     * Picks the fields from attributes.
-     * @param attrs
-     * @param include_parents Include the parent fields
-     * @param include_navigation Include the navigation fields
-     * @param include_etag Include the etag field
-     * @returns The picked fields
-     */
-    pick(attrs: {
-        [name: string]: any;
-    }, { include_id, include_key, include_parents, include_navigation, include_computed, include_etag, options, }?: {
-        include_id?: boolean;
-        include_key?: boolean;
-        include_parents?: boolean;
-        include_navigation?: boolean;
-        include_computed?: boolean;
-        include_etag?: boolean;
-        options?: ParserOptions;
-    }): Partial<T>;
-    resolveKey(value: any, { resolve, single, }?: {
-        resolve?: boolean;
-        single?: boolean;
-    }): any;
-    defaults(): {
-        [name: string]: any;
-    };
-    toJsonSchema(options?: JsonSchemaOptions<T>): any;
-    validate(attrs: any, { method, navigation, }?: {
-        create?: boolean;
-        method?: 'create' | 'update' | 'modify';
-        navigation?: boolean;
-    }): {
-        [name: string]: any;
-    } | undefined;
-}
-export {};

package/lib/schema/schema.d.ts

@@ -1,26 +0,0 @@
-import { ODataApi } from '../api';
-import { ParserOptions, ODataSchemaConfig, ODataStructuredTypeConfig } from '../types';
-import { ODataAnnotatable } from './annotation';
-import { ODataCallable } from './callable';
-import { ODataEntityContainer } from './entity-container';
-import { ODataEntitySet } from './entity-set';
-import { ODataEnumType } from './enum-type';
-import { ODataSingleton } from './singleton';
-import { ODataStructuredType } from './structured-type';
-export declare class ODataSchema extends ODataAnnotatable {
-    api: ODataApi;
-    namespace: string;
-    alias?: string;
-    enums: ODataEnumType<any>[];
-    entities: ODataStructuredType<any>[];
-    callables: ODataCallable<any>[];
-    containers: ODataEntityContainer[];
-    constructor(config: ODataSchemaConfig, api: ODataApi);
-    isNamespaceOf(type: string): boolean;
-    get entitySets(): ODataEntitySet[];
-    get singletons(): ODataSingleton[];
-    createStructuredType<T>(config: ODataStructuredTypeConfig): ODataStructuredType<T>;
-    configure({ options }: {
-        options: ParserOptions;
-    }): void;
-}

package/lib/schema/singleton.d.ts

@@ -1,10 +0,0 @@
-import { ODataSingletonConfig } from '../types';
-import { ODataSchemaElement } from './element';
-import { ODataSchema } from './schema';
-export declare class ODataSingleton extends ODataSchemaElement {
-    singletonType: string;
-    service: {
-        new (...params: any[]): any;
-    };
-    constructor(config: ODataSingletonConfig, schema: ODataSchema);
-}