angular-odata 0.131.0 → 0.140.1

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

@@ -1,152 +0,0 @@
-import { ODataCollection } from '../models/collection';
-import { ODataModel } from '../models/model';
-import { ParserOptions, ODataStructuredTypeConfig, ODataStructuredTypeFieldConfig } from '../types';
-import { ODataParserSchemaElement } from './element';
-import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
-import { ODataSchema } from './schema';
-export declare class ODataStructuredType<T> extends ODataParserSchemaElement<T, ODataStructuredTypeParser<T>> {
-    base?: string;
-    parent?: ODataStructuredType<any>;
-    children: ODataStructuredType<any>[];
-    model?: typeof ODataModel;
-    collection?: typeof ODataCollection;
-    constructor(config: ODataStructuredTypeConfig, schema: ODataSchema);
-    configure({ options }: {
-        options: ParserOptions;
-    }): void;
-    /**
-     * 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(schema: ODataStructuredType<any>): 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(schema: ODataStructuredType<any>): boolean;
-    /**
-     * Returns a boolean indicating if the structured type has a simple key.
-     * @returns True if the structured type has a simple key
-     */
-    isSimpleKey(): boolean;
-    /**
-     * Returns a boolean indicating if the structured type has a compound key.
-     * @returns True if the structured type has a compound key.
-     */
-    isCompoundKey(): boolean;
-    isOpenType(): boolean;
-    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>;
-    addField<F>(name: string, config: ODataStructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
-    /**
-     * Find a parent schema of the structured type.
-     * @param predicate Function for evaluate the schemas in the hierarchy.
-     * @returns The schema that matches the predicate.
-     */
-    findParentSchema(predicate: (p: ODataStructuredType<any>) => boolean): ODataStructuredType<any> | undefined;
-    findChildSchema(predicate: (p: ODataStructuredType<any>) => boolean): ODataStructuredType<any> | undefined;
-    /**
-     * Find a parent schema of the structured type for the given field.
-     * @param field Field that belongs to the structured type
-     * @returns The schema of the field
-     */
-    findParentSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
-    /**
-     * 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, }?: {
-        include_id?: boolean;
-        include_key?: boolean;
-        include_parents?: boolean;
-        include_navigation?: boolean;
-        include_computed?: boolean;
-        include_etag?: boolean;
-    }): Partial<T>;
-    /**
-     * Deseialize the given value from the structured type.
-     * @param value Value to deserialize
-     * @param options Options for deserialization
-     * @returns Deserialized value
-     */
-    deserialize(value: any, options?: ParserOptions): T;
-    /**
-     * Serialize the given value for the structured type.
-     * @param value Value to serialize
-     * @param options Options for serialization
-     * @returns Serialized value
-     */
-    serialize(value: T, options?: ParserOptions): any;
-    /**
-     * Encode the given value for the structured type.
-     * @param value Value to encode
-     * @param options Options for encoding
-     * @returns Encoded value
-     */
-    encode(value: T, options?: ParserOptions): any;
-    /**
-     * 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[];
-    /**
-     * Resolve the key of the structured type for the given value.
-     * @param attrs Attributes of the value
-     * @returns Resolved key
-     */
-    resolveKey(attrs: T | {
-        [name: string]: any;
-    }): any;
-    /**
-     * Returns the defaults values for the structured type.
-     * @returns Default values for the structured type
-     */
-    defaults(): {
-        [name: string]: any;
-    };
-    /**
-     * Convert the structured type to json schema
-     * @param options Options for json schema
-     * @returns Json Schema
-     */
-    toJsonSchema(options?: JsonSchemaOptions<T>): any;
-    /**
-     * Validate the given value against the structured type.
-     * @param attrs Attributes of the value
-     * @param method Method to use for the process validation
-     * @returns Object with the errors
-     */
-    validate(attrs: Partial<T>, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'modify';
-        navigation?: boolean;
-    }): {
-        [name: string]: any;
-    } | undefined;
-}

package/lib/services/base.d.ts

@@ -1,20 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataClient } from '../client';
-import { ODataActionOptions, ODataActionResource, ODataEntities, ODataEntity, ODataFunctionOptions, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
-export declare abstract class ODataBaseService {
-    protected client: ODataClient;
-    protected name: string;
-    protected apiNameOrEntityType?: string | undefined;
-    constructor(client: ODataClient, name: string, apiNameOrEntityType?: string | undefined);
-    get api(): import("angular-odata").ODataApi;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataFunctionOptions<R>): Observable<ODataEntity<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataFunctionOptions<R>): Observable<ODataEntities<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataFunctionOptions<R>): Observable<ODataProperty<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataFunctionOptions<R>): Observable<null>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataActionOptions<R>): Observable<ODataEntity<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataActionOptions<R>): Observable<ODataEntities<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataActionOptions<R>): Observable<ODataProperty<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataActionOptions<R>): Observable<null>;
-    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entity', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntity<S>>;
-    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entities', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntities<S>>;
-}

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

@@ -1,120 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataCollection } from '../models/collection';
-import { ODataModel } from '../models/model';
-import { EntityKey, ODataEntity, ODataEntityResource, ODataEntitySetResource, ODataOptions } from '../resources';
-import { ODataEntityService } from './entity';
-export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
-    static Model?: typeof ODataModel;
-    static Collection?: typeof ODataCollection;
-    model(entity?: Partial<T>, reset?: boolean): ODataModel<T> & import("angular-odata").ModelInterface<T>;
-    collection(entities?: Partial<T>[], reset?: boolean): ODataCollection<T, ODataModel<T> & import("angular-odata").ModelInterface<T>>;
-    /**
-     * Get the entity set resource for this service.
-     */
-    entities(): ODataEntitySetResource<T>;
-    /**
-     * Get the entity resource for this service.
-     * @param key The entity key.
-     */
-    entity(key?: EntityKey<T>): ODataEntityResource<T>;
-    /**
-     * Attach an existing model to this service.
-     * @param model The model to attach.
-     */
-    attach<M extends ODataModel<T>>(model: M): void;
-    attach<C extends ODataCollection<T, ODataModel<T>>>(model: C): void;
-    /**
-     * The schema for the entity set.
-     */
-    get entitySetSchema(): import("angular-odata").ODataEntitySet | undefined;
-    /**
-     * Get all entities from the entity set.
-     * @param options The options for the request.
-     */
-    fetchAll(options?: ODataOptions): Observable<{
-        entities: any[];
-        annots: import("angular-odata").ODataEntitiesAnnotations<any>;
-    }>;
-    /**
-     * Get entities from the entity set.
-     * @param withCount Get the count of the entities.
-     * @param options The options for the request.
-     */
-    fetchMany(top: number, options?: ODataOptions & {
-        withCount?: boolean;
-    }): Observable<{
-        entities: T[];
-        annots: import("angular-odata").ODataEntitiesAnnotations<T>;
-    } | {
-        entities: T[];
-        annots: import("angular-odata").ODataEntitiesAnnotations<any>;
-    }>;
-    /**
-     * Get an entity from the entity set.
-     * @param key The entity key.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    fetchOne(options?: ODataOptions & {
-        etag?: string;
-    }): Observable<{
-        entity: T | null;
-        annots: import("angular-odata").ODataEntitiesAnnotations<T>;
-    }>;
-    /**
-     * Create an entity in the entity set.
-     * @param attrs The attributes for the entity.
-     * @param options The options for the request.
-     */
-    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    /**
-     * Update an entity in the entity set.
-     * @param key The entity key.
-     * @param attrs The attributes for the entity.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    update(key: EntityKey<T>, attrs: Partial<T>, options?: ODataOptions & {
-        etag?: string;
-    }): Observable<ODataEntity<T>>;
-    /**
-     * Patch an entity in the entity set.
-     * @param key The entity key.
-     * @param attrs The attributes for the entity.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    modify(key: EntityKey<T>, attrs: Partial<T>, options?: ODataOptions & {
-        etag?: string;
-    }): Observable<ODataEntity<T>>;
-    /**
-     * Delete an entity in the entity set.
-     * @param key The entity key.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    destroy(key: EntityKey<T>, options?: ODataOptions & {
-        etag?: string;
-    }): Observable<any>;
-    /**
-     * Get or create an entity in the entity set.
-     * @param key The entity key.
-     * @param attrs The attributes for the entity.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    fetchOrCreate(key: EntityKey<T>, attrs: Partial<T>, { etag, ...options }?: {
-        etag?: string;
-    } & ODataOptions): Observable<ODataEntity<T>>;
-    /**
-     * Save an entity in the entity set.
-     * @param attrs The attributes for the entity.
-     * @param method The method to use.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    save(attrs: Partial<T>, { etag, method, ...options }?: {
-        etag?: string;
-        method?: 'create' | 'update' | 'modify';
-    } & ODataOptions): Observable<ODataEntity<T>>;
-}

package/lib/services/entity.d.ts

@@ -1,11 +0,0 @@
-import { ODataModel } from '../models/model';
-import { EntityKey, ODataResource } from '../resources';
-import { ODataBaseService } from './base';
-export declare abstract class ODataEntityService<T> extends ODataBaseService {
-    abstract entity(key?: EntityKey<T>): ODataResource<T>;
-    abstract attach<M extends ODataModel<T>>(value: M): void;
-    /**
-     * The schema for the structured type.
-     */
-    get structuredTypeSchema(): import("angular-odata").ODataStructuredType<any> | import("angular-odata").ODataStructuredType<T> | undefined;
-}

package/lib/services/factory.d.ts

@@ -1,33 +0,0 @@
-import { ODataClient } from '../client';
-import { ODataEntitySetService } from './entity-set';
-import { ODataSingletonService } from './singleton';
-import { ODataCollection, ODataModel } from '../models';
-import * as i0 from "@angular/core";
-export declare class ODataServiceFactory {
-    protected client: ODataClient;
-    constructor(client: ODataClient);
-    /**
-     * Factory method to create an entity set service.
-     * @param entitySetName Name of the entity set.
-     * @param apiNameOrEntityType Name of the API or the type of the entity.
-     */
-    entitySet<T>(entitySetName: string, apiNameOrEntityType?: string, options?: {
-        Model?: {
-            new (...params: any[]): ODataModel<T>;
-        };
-        Collection?: {
-            new (...params: any[]): ODataCollection<T, ODataModel<T>>;
-        };
-    }): ODataEntitySetService<T>;
-    /** Factory method to create a singleton service.
-     * @param singletonName Name of the singleton.
-     * @param apiNameOrEntityType Name of the API or the type of the entity.
-     */
-    singleton<T>(singletonName: string, apiNameOrEntityType?: string, options?: {
-        Model?: {
-            new (...params: any[]): ODataModel<T>;
-        };
-    }): ODataSingletonService<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ODataServiceFactory, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ODataServiceFactory>;
-}

package/lib/services/index.d.ts

@@ -1,4 +0,0 @@
-export * from './base';
-export * from './entity-set';
-export * from './singleton';
-export * from './factory';

package/lib/services/singleton.d.ts

@@ -1,44 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataModel } from '../models/model';
-import { ODataEntity, ODataOptions, ODataSingletonResource } from '../resources';
-import { ODataEntityService } from './entity';
-/**
- * OData Singleton Service
- * www.odata.org/getting-started/advanced-tutorial/#singleton
- */
-export declare class ODataSingletonService<T> extends ODataEntityService<T> {
-    static Model?: typeof ODataModel;
-    model(entity?: Partial<T>): ODataModel<T> & import("angular-odata").ModelInterface<T>;
-    /**
-     * Get the entity resource for this service.
-     * @param key The entity key.
-     */
-    entity(): ODataSingletonResource<T>;
-    /**
-     * Attach an existing model to this service.
-     * @param model The model to attach.
-     */
-    attach<M extends ODataModel<T>>(model: M): void;
-    /**
-     * The schema for the singleton.
-     */
-    get singletonSchema(): import("angular-odata").ODataEntitySet | undefined;
-    /**
-     * Update the singleton entity
-     * @param attrs The attributes for the entity.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    update(attrs: Partial<T>, options?: ODataOptions & {
-        etag?: string;
-    }): Observable<ODataEntity<T>>;
-    /**
-     * Patch the singleton entity
-     * @param attrs The attributes for the entity.
-     * @param etag The etag for the entity.
-     * @param options The options for the request.
-     */
-    patch(attrs: Partial<T>, options?: ODataOptions & {
-        etag?: string;
-    }): Observable<ODataEntity<T>>;
-}

package/lib/settings.d.ts

@@ -1,26 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from './api';
-import { ODataCollection, ODataModel } from './models';
-import { ODataRequest } from './resources';
-import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
-import { ODataApiConfig, EdmType, Parser } from './types';
-export declare class ODataSettings {
-    apis: ODataApi[];
-    constructor(configs: ODataApiConfig[]);
-    configure(settings: {
-        requester?: (request: ODataRequest<any>) => Observable<any>;
-    }): void;
-    defaultApi(): ODataApi;
-    findApiByName(name: string): ODataApi | undefined;
-    apiByName(name: string): ODataApi;
-    findApiForTypes(types: string[]): ODataApi | undefined;
-    findApiForType(type: string): ODataApi | undefined;
-    apiForType(type: string): ODataApi;
-    enumTypeForType<T>(type: string): ODataEnumType<T>;
-    structuredTypeForType<T>(type: string): ODataStructuredType<T>;
-    callableForType<T>(type: string, bindingType?: string): ODataCallable<T>;
-    entitySetForType(type: string): ODataEntitySet;
-    parserForType<T>(type: string | EdmType): Parser<T>;
-    modelForType(type: string): typeof ODataModel;
-    collectionForType(type: string): typeof ODataCollection;
-}