tmf API 674 - Geographic Site Management

import { HttpParameterCodec } from '@angular/common/http';

import { Param } from './param';

export interface ConfigurationParameters {

    /**

     *  @deprecated Since 5.0. Use credentials instead

     */

    apiKeys?: {[ key: string ]: string};

    username?: string;

    password?: string;

    /**

     *  @deprecated Since 5.0. Use credentials instead

     */

    accessToken?: string | (() => string);

    basePath?: string;

    withCredentials?: boolean;

    /**

     * Takes care of encoding query- and form-parameters.

     */

    encoder?: HttpParameterCodec;

    /**

     * Override the default method for encoding path parameters in various

     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.

     * <p>

     * See {@link README.md} for more details

     * </p>

     */

    encodeParam?: (param: Param) => string;

    /**

     * The keys are the names in the securitySchemes section of the OpenAPI

     * document. They should map to the value used for authentication

     * minus any standard prefixes such as 'Basic' or 'Bearer'.

     */

    credentials?: {[ key: string ]: string | (() => string | undefined)};

}

export class Configuration {

    /**

     *  @deprecated Since 5.0. Use credentials instead

     */

    apiKeys?: {[ key: string ]: string};

    username?: string;

    password?: string;

    /**

     *  @deprecated Since 5.0. Use credentials instead

     */

    accessToken?: string | (() => string);

    basePath?: string;

    withCredentials?: boolean;

    /**

     * Takes care of encoding query- and form-parameters.

     */

    encoder?: HttpParameterCodec;

    /**

     * Encoding of various path parameter

     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.

     * <p>

     * See {@link README.md} for more details

     * </p>

     */

    encodeParam: (param: Param) => string;

    /**

     * The keys are the names in the securitySchemes section of the OpenAPI

     * document. They should map to the value used for authentication

     * minus any standard prefixes such as 'Basic' or 'Bearer'.

     */

    credentials: {[ key: string ]: string | (() => string | undefined)};

    constructor(configurationParameters: ConfigurationParameters = {}) {

        this.apiKeys = configurationParameters.apiKeys;

        this.username = configurationParameters.username;

        this.password = configurationParameters.password;

        this.accessToken = configurationParameters.accessToken;

        this.basePath = configurationParameters.basePath;

        this.withCredentials = configurationParameters.withCredentials;

        this.encoder = configurationParameters.encoder;

        if (configurationParameters.encodeParam) {

            this.encodeParam = configurationParameters.encodeParam;

        }

        else {

            this.encodeParam = param => this.defaultEncodeParam(param);

        }

        if (configurationParameters.credentials) {

            this.credentials = configurationParameters.credentials;

        }

        else {

            this.credentials = {};

        }

    }

    /**

     * Select the correct content-type to use for a request.

     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.

     * If no content type is found return the first found type if the contentTypes is not empty

     * @param contentTypes - the array of content types that are available for selection

     * @returns the selected content-type or <code>undefined</code> if no selection could be made.

     */

    public selectHeaderContentType (contentTypes: string[]): string | undefined {

        if (contentTypes.length === 0) {

            return undefined;

        }

        const type = contentTypes.find((x: string) => this.isJsonMime(x));

        if (type === undefined) {

            return contentTypes[0];

        }

        return type;

    }

    /**

     * Select the correct accept content-type to use for a request.

     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.

     * If no content type is found return the first found type if the contentTypes is not empty

     * @param accepts - the array of content types that are available for selection.

     * @returns the selected content-type or <code>undefined</code> if no selection could be made.

     */

    public selectHeaderAccept(accepts: string[]): string | undefined {

        if (accepts.length === 0) {

            return undefined;

        }

        const type = accepts.find((x: string) => this.isJsonMime(x));

        if (type === undefined) {

            return accepts[0];

        }

        return type;

    }

    /**

     * Check if the given MIME is a JSON MIME.

     * JSON MIME examples:

     *   application/json

     *   application/json; charset=UTF8

     *   APPLICATION/JSON

     *   application/vnd.company+json

     * @param mime - MIME (Multipurpose Internet Mail Extensions)

     * @return True if the given MIME is JSON, false otherwise.

     */

    public isJsonMime(mime: string): boolean {

        const jsonMime: RegExp = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');

        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');

    }

    public lookupCredential(key: string): string | undefined {

        const value = this.credentials[key];

        return typeof value === 'function'

            ? value()

            : value;

    }

    private defaultEncodeParam(param: Param): string {

        // This implementation exists as fallback for missing configuration

        // and for backwards compatibility to older typescript-angular generator versions.

        // It only works for the 'simple' parameter style.

        // Date-handling only works for the 'date-time' format.

        // All other styles and Date-formats are probably handled incorrectly.

        //

        // But: if that's all you need (i.e.: the most common use-case): no need for customization!

        const value = param.dataFormat === 'date-time' && param.value instanceof Date

            ? (param.value as Date).toISOString()

            : param.value;

        return encodeURIComponent(String(value));

    }

    export class ApiConfiguration {

      rootUrl: string = '//portal.openslice.io/osapi';

    }

}

import { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';

import { Configuration } from './configuration';

import { HttpClient } from '@angular/common/http';

@NgModule({

  imports:      [],

  declarations: [],

  exports:      [],

  providers: []

})

export class ApiModule {

    public static forRoot(configurationFactory: () => Configuration): ModuleWithProviders<ApiModule> {

        return {

            ngModule: ApiModule,

            providers: [ { provide: Configuration, useFactory: configurationFactory } ]

        };

    }

    constructor( @Optional() @SkipSelf() parentModule: ApiModule,

                 @Optional() http: HttpClient) {

        if (parentModule) {

            throw new Error('ApiModule is already loaded. Import in your base AppModule only.');

        }

        if (!http) {

            throw new Error('You need to import the HttpClientModule in your AppModule! \n' +

            'See also https://github.com/angular/angular/issues/20575');

        }

    }

}

import { HttpParameterCodec } from '@angular/common/http';

/**

 * Custom HttpParameterCodec

 * Workaround for https://github.com/angular/angular/issues/18261

 */

export class CustomHttpParameterCodec implements HttpParameterCodec {

    encodeKey(k: string): string {

        return encodeURIComponent(k);

    }

    encodeValue(v: string): string {

        return encodeURIComponent(v);

    }

    decodeKey(k: string): string {

        return decodeURIComponent(k);

    }

    decodeValue(v: string): string {

        return decodeURIComponent(v);

    }

}

export * from './api/api';

export * from './model/models';

export * from './variables';

export * from './configuration';

export * from './api.module';

export * from './param';

/**

 * Geographic Site Management

 * ** TMF API Reference : TMF 674 - Place - Geographic Site Management  ### August 2021  This API covers the operations to manage (create, read, delete) sites that can be associated to a customer, an account, a service delivery or other entities. It defines a Site as a convenience class that allows to easily refer to places important to other entities, where a geographic place is the entity that can answer the question “where?”, allowing to determine where things are in relation to the earth\'s surface, and can be represented either in a textual structured way (geographic address) or as a geometry referred to a spatial reference system (geographic location).  ### Resources - GeographicSite - Hub  ### Operations Geographic Site API performs the following operations : - Retrieve a geographic site or a collection of geographic sites - Create a new site - Update a geographic site - Delete a geographic site - Notify events on geographic site  Copyright © TM Forum 2021. All Rights Reserved  

 *

 * The version of the OpenAPI document: 5.0.0

 * 

 *

 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

 * https://openapi-generator.tech

 * Do not edit the class manually.

 */

/**

 * Base schema for adressable entities

 */

export interface Addressable { 

    /**

     * Hyperlink reference

     */

    href: string;

    /**

     * unique identifier

     */

    id: string;

}