@revxui/intellibid-client-ts 1.0.55 → 1.0.57

package/README.md

@@ -1,4 +1,4 @@
-## @revxui/intellibid-client-ts@1.0.55
+## @revxui/intellibid-client-ts@1.0.57
 
 ### Building
 
@@ -19,7 +19,7 @@ Navigate to the folder of your consuming project and run one of next commands.
 _published:_
 
 ```
-npm install @revxui/intellibid-client-ts@1.0.55 --save
+npm install @revxui/intellibid-client-ts@1.0.57 --save
 ```
 
 _without publishing (not recommended):_

package/api/api.d.ts

@@ -1,7 +1,11 @@
 export * from './advertiserController.service';
 import { AdvertiserControllerService } from './advertiserController.service';
+export * from './audienceController.service';
+import { AudienceControllerService } from './audienceController.service';
 export * from './campaignController.service';
 import { CampaignControllerService } from './campaignController.service';
 export * from './insightsController.service';
 import { InsightsControllerService } from './insightsController.service';
-export declare const APIS: (typeof AdvertiserControllerService | typeof CampaignControllerService | typeof InsightsControllerService)[];
+export * from './osMasterController.service';
+import { OsMasterControllerService } from './osMasterController.service';
+export declare const APIS: (typeof AdvertiserControllerService | typeof AudienceControllerService | typeof CampaignControllerService | typeof InsightsControllerService | typeof OsMasterControllerService)[];

package/api/audienceController.service.d.ts

@@ -0,0 +1,63 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { AudienceListResponse } from '../model/audienceListResponse';
+import { CreateBlockedAudienceRequest } from '../model/createBlockedAudienceRequest';
+import { CreateDynamicAudienceRequest } from '../model/createDynamicAudienceRequest';
+import { CreateStaticAudienceRequest } from '../model/createStaticAudienceRequest';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+export declare class AudienceControllerService {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    constructor(httpClient: HttpClient, basePath: string, configuration: Configuration);
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    private canConsumeForm;
+    /**
+     *
+     *
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    createBlockedAudience(body: CreateBlockedAudienceRequest, observe?: 'body', reportProgress?: boolean): Observable<any>;
+    createBlockedAudience(body: CreateBlockedAudienceRequest, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;
+    createBlockedAudience(body: CreateBlockedAudienceRequest, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;
+    /**
+     *
+     *
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    createDynamicAudiences(body: CreateDynamicAudienceRequest, observe?: 'body', reportProgress?: boolean): Observable<any>;
+    createDynamicAudiences(body: CreateDynamicAudienceRequest, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;
+    createDynamicAudiences(body: CreateDynamicAudienceRequest, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;
+    /**
+     *
+     *
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    createStaticAudiences(body: CreateStaticAudienceRequest, observe?: 'body', reportProgress?: boolean): Observable<any>;
+    createStaticAudiences(body: CreateStaticAudienceRequest, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;
+    createStaticAudiences(body: CreateStaticAudienceRequest, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;
+    /**
+     *
+     *
+     * @param advertiserId
+     * @param sourcePlatform
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    getAudiences(advertiserId: number, sourcePlatform: string, observe?: 'body', reportProgress?: boolean): Observable<AudienceListResponse>;
+    getAudiences(advertiserId: number, sourcePlatform: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<AudienceListResponse>>;
+    getAudiences(advertiserId: number, sourcePlatform: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<AudienceListResponse>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudienceControllerService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AudienceControllerService>;
+}

package/api/osMasterController.service.d.ts

@@ -0,0 +1,28 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { OSResponse } from '../model/oSResponse';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+export declare class OsMasterControllerService {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    constructor(httpClient: HttpClient, basePath: string, configuration: Configuration);
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    private canConsumeForm;
+    /**
+     *
+     *
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    getAllActiveOS(observe?: 'body', reportProgress?: boolean): Observable<Array<OSResponse>>;
+    getAllActiveOS(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<OSResponse>>>;
+    getAllActiveOS(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<OSResponse>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OsMasterControllerService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OsMasterControllerService>;
+}

package/esm2020/api/api.mjs

@@ -1,8 +1,12 @@
 export * from './advertiserController.service';
 import { AdvertiserControllerService } from './advertiserController.service';
+export * from './audienceController.service';
+import { AudienceControllerService } from './audienceController.service';
 export * from './campaignController.service';
 import { CampaignControllerService } from './campaignController.service';
 export * from './insightsController.service';
 import { InsightsControllerService } from './insightsController.service';
-export const APIS = [AdvertiserControllerService, CampaignControllerService, InsightsControllerService];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vYXBpL2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzdFLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDekUsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUN6RSxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUcsQ0FBQywyQkFBMkIsRUFBRSx5QkFBeUIsRUFBRSx5QkFBeUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hZHZlcnRpc2VyQ29udHJvbGxlci5zZXJ2aWNlJztcbmltcG9ydCB7IEFkdmVydGlzZXJDb250cm9sbGVyU2VydmljZSB9IGZyb20gJy4vYWR2ZXJ0aXNlckNvbnRyb2xsZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NhbXBhaWduQ29udHJvbGxlci5zZXJ2aWNlJztcbmltcG9ydCB7IENhbXBhaWduQ29udHJvbGxlclNlcnZpY2UgfSBmcm9tICcuL2NhbXBhaWduQ29udHJvbGxlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaW5zaWdodHNDb250cm9sbGVyLnNlcnZpY2UnO1xuaW1wb3J0IHsgSW5zaWdodHNDb250cm9sbGVyU2VydmljZSB9IGZyb20gJy4vaW5zaWdodHNDb250cm9sbGVyLnNlcnZpY2UnO1xuZXhwb3J0IGNvbnN0IEFQSVMgPSBbQWR2ZXJ0aXNlckNvbnRyb2xsZXJTZXJ2aWNlLCBDYW1wYWlnbkNvbnRyb2xsZXJTZXJ2aWNlLCBJbnNpZ2h0c0NvbnRyb2xsZXJTZXJ2aWNlXTtcbiJdfQ==
+export * from './osMasterController.service';
+import { OsMasterControllerService } from './osMasterController.service';
+export const APIS = [AdvertiserControllerService, AudienceControllerService, CampaignControllerService, InsightsControllerService, OsMasterControllerService];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vYXBpL2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzdFLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDekUsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUN6RSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3pFLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDekUsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFHLENBQUMsMkJBQTJCLEVBQUUseUJBQXlCLEVBQUUseUJBQXlCLEVBQUUseUJBQXlCLEVBQUUseUJBQXlCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWR2ZXJ0aXNlckNvbnRyb2xsZXIuc2VydmljZSc7XG5pbXBvcnQgeyBBZHZlcnRpc2VyQ29udHJvbGxlclNlcnZpY2UgfSBmcm9tICcuL2FkdmVydGlzZXJDb250cm9sbGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9hdWRpZW5jZUNvbnRyb2xsZXIuc2VydmljZSc7XG5pbXBvcnQgeyBBdWRpZW5jZUNvbnRyb2xsZXJTZXJ2aWNlIH0gZnJvbSAnLi9hdWRpZW5jZUNvbnRyb2xsZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NhbXBhaWduQ29udHJvbGxlci5zZXJ2aWNlJztcbmltcG9ydCB7IENhbXBhaWduQ29udHJvbGxlclNlcnZpY2UgfSBmcm9tICcuL2NhbXBhaWduQ29udHJvbGxlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaW5zaWdodHNDb250cm9sbGVyLnNlcnZpY2UnO1xuaW1wb3J0IHsgSW5zaWdodHNDb250cm9sbGVyU2VydmljZSB9IGZyb20gJy4vaW5zaWdodHNDb250cm9sbGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9vc01hc3RlckNvbnRyb2xsZXIuc2VydmljZSc7XG5pbXBvcnQgeyBPc01hc3RlckNvbnRyb2xsZXJTZXJ2aWNlIH0gZnJvbSAnLi9vc01hc3RlckNvbnRyb2xsZXIuc2VydmljZSc7XG5leHBvcnQgY29uc3QgQVBJUyA9IFtBZHZlcnRpc2VyQ29udHJvbGxlclNlcnZpY2UsIEF1ZGllbmNlQ29udHJvbGxlclNlcnZpY2UsIENhbXBhaWduQ29udHJvbGxlclNlcnZpY2UsIEluc2lnaHRzQ29udHJvbGxlclNlcnZpY2UsIE9zTWFzdGVyQ29udHJvbGxlclNlcnZpY2VdO1xuIl19

package/esm2020/api/audienceController.service.mjs

@@ -0,0 +1,174 @@
+/**
+ * Intellibid API
+ * API documentation for the Intellibid platform
+ *
+ * OpenAPI spec version: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */ /* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { CustomHttpUrlEncodingCodec } from '../encoder';
+import { BASE_PATH } from '../variables';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../configuration";
+export class AudienceControllerService {
+    constructor(httpClient, basePath, configuration) {
+        this.httpClient = httpClient;
+        this.basePath = 'http://dev1-intellibid-svc.revx.io';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = basePath || configuration.basePath || this.basePath;
+        }
+    }
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    canConsumeForm(consumes) {
+        const form = 'multipart/form-data';
+        for (const consume of consumes) {
+            if (form === consume) {
+                return true;
+            }
+        }
+        return false;
+    }
+    createBlockedAudience(body, observe = 'body', reportProgress = false) {
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling createBlockedAudience.');
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('post', `${this.basePath}/api/audiences/blocked`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    createDynamicAudiences(body, observe = 'body', reportProgress = false) {
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling createDynamicAudiences.');
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('post', `${this.basePath}/api/audiences/product-set`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    createStaticAudiences(body, observe = 'body', reportProgress = false) {
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling createStaticAudiences.');
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('post', `${this.basePath}/api/audiences/static`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    getAudiences(advertiserId, sourcePlatform, observe = 'body', reportProgress = false) {
+        if (advertiserId === null || advertiserId === undefined) {
+            throw new Error('Required parameter advertiserId was null or undefined when calling getAudiences.');
+        }
+        if (sourcePlatform === null || sourcePlatform === undefined) {
+            throw new Error('Required parameter sourcePlatform was null or undefined when calling getAudiences.');
+        }
+        let queryParameters = new HttpParams({ encoder: new CustomHttpUrlEncodingCodec() });
+        if (advertiserId !== undefined && advertiserId !== null) {
+            queryParameters = queryParameters.set('advertiserId', advertiserId);
+        }
+        if (sourcePlatform !== undefined && sourcePlatform !== null) {
+            queryParameters = queryParameters.set('sourcePlatform', sourcePlatform);
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [
+            '*/*'
+        ];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [];
+        return this.httpClient.request('get', `${this.basePath}/api/audiences`, {
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+}
+AudienceControllerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AudienceControllerService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+AudienceControllerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AudienceControllerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AudienceControllerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BASE_PATH]
+                }] }, { type: i2.Configuration, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audienceController.service.js","sourceRoot":"","sources":["../../../api/audienceController.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Intellibid API\n * API documentation for the Intellibid platform\n *\n * OpenAPI spec version: 1.0\n * \n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n *//* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent }                           from '@angular/common/http';\nimport { CustomHttpUrlEncodingCodec }                        from '../encoder';\n\nimport { Observable }                                        from 'rxjs';\n\nimport { AudienceListResponse } from '../model/audienceListResponse';\nimport { CreateBlockedAudienceRequest } from '../model/createBlockedAudienceRequest';\nimport { CreateDynamicAudienceRequest } from '../model/createDynamicAudienceRequest';\nimport { CreateStaticAudienceRequest } from '../model/createStaticAudienceRequest';\n\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\n@Injectable()\nexport class AudienceControllerService {\n\n    protected basePath = 'http://dev1-intellibid-svc.revx.io';\n    public defaultHeaders = new HttpHeaders();\n    public configuration = new Configuration();\n\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\n        if (basePath) {\n            this.basePath = basePath;\n        }\n        if (configuration) {\n            this.configuration = configuration;\n            this.basePath = basePath || configuration.basePath || this.basePath;\n        }\n    }\n\n    /**\n     * @param consumes string[] mime-types\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\n     */\n    private canConsumeForm(consumes: string[]): boolean {\n        const form = 'multipart/form-data';\n        for (const consume of consumes) {\n            if (form === consume) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n\n    /**\n     * \n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public createBlockedAudience(body: CreateBlockedAudienceRequest, observe?: 'body', reportProgress?: boolean): Observable<any>;\n    public createBlockedAudience(body: CreateBlockedAudienceRequest, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;\n    public createBlockedAudience(body: CreateBlockedAudienceRequest, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;\n    public createBlockedAudience(body: CreateBlockedAudienceRequest, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling createBlockedAudience.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<any>('post',`${this.basePath}/api/audiences/blocked`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * \n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public createDynamicAudiences(body: CreateDynamicAudienceRequest, observe?: 'body', reportProgress?: boolean): Observable<any>;\n    public createDynamicAudiences(body: CreateDynamicAudienceRequest, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;\n    public createDynamicAudiences(body: CreateDynamicAudienceRequest, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;\n    public createDynamicAudiences(body: CreateDynamicAudienceRequest, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling createDynamicAudiences.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<any>('post',`${this.basePath}/api/audiences/product-set`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * \n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public createStaticAudiences(body: CreateStaticAudienceRequest, observe?: 'body', reportProgress?: boolean): Observable<any>;\n    public createStaticAudiences(body: CreateStaticAudienceRequest, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;\n    public createStaticAudiences(body: CreateStaticAudienceRequest, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;\n    public createStaticAudiences(body: CreateStaticAudienceRequest, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling createStaticAudiences.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<any>('post',`${this.basePath}/api/audiences/static`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * \n     * \n     * @param advertiserId \n     * @param sourcePlatform \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getAudiences(advertiserId: number, sourcePlatform: string, observe?: 'body', reportProgress?: boolean): Observable<AudienceListResponse>;\n    public getAudiences(advertiserId: number, sourcePlatform: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<AudienceListResponse>>;\n    public getAudiences(advertiserId: number, sourcePlatform: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<AudienceListResponse>>;\n    public getAudiences(advertiserId: number, sourcePlatform: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (advertiserId === null || advertiserId === undefined) {\n            throw new Error('Required parameter advertiserId was null or undefined when calling getAudiences.');\n        }\n\n        if (sourcePlatform === null || sourcePlatform === undefined) {\n            throw new Error('Required parameter sourcePlatform was null or undefined when calling getAudiences.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (advertiserId !== undefined && advertiserId !== null) {\n            queryParameters = queryParameters.set('advertiserId', <any>advertiserId);\n        }\n        if (sourcePlatform !== undefined && sourcePlatform !== null) {\n            queryParameters = queryParameters.set('sourcePlatform', <any>sourcePlatform);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            '*/*'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<AudienceListResponse>('get',`${this.basePath}/api/audiences`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n"]}

package/esm2020/api/osMasterController.service.mjs

@@ -0,0 +1,78 @@
+/**
+ * Intellibid API
+ * API documentation for the Intellibid platform
+ *
+ * OpenAPI spec version: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */ /* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { BASE_PATH } from '../variables';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../configuration";
+export class OsMasterControllerService {
+    constructor(httpClient, basePath, configuration) {
+        this.httpClient = httpClient;
+        this.basePath = 'http://dev1-intellibid-svc.revx.io';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = basePath || configuration.basePath || this.basePath;
+        }
+    }
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    canConsumeForm(consumes) {
+        const form = 'multipart/form-data';
+        for (const consume of consumes) {
+            if (form === consume) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getAllActiveOS(observe = 'body', reportProgress = false) {
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [
+            '*/*'
+        ];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [];
+        return this.httpClient.request('get', `${this.basePath}/api/os`, {
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+}
+OsMasterControllerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: OsMasterControllerService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+OsMasterControllerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: OsMasterControllerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: OsMasterControllerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BASE_PATH]
+                }] }, { type: i2.Configuration, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api.module.mjs

@@ -1,8 +1,10 @@
 import { NgModule, SkipSelf, Optional } from '@angular/core';
 import { Configuration } from './configuration';
 import { AdvertiserControllerService } from './api/advertiserController.service';
+import { AudienceControllerService } from './api/audienceController.service';
 import { CampaignControllerService } from './api/campaignController.service';
 import { InsightsControllerService } from './api/insightsController.service';
+import { OsMasterControllerService } from './api/osMasterController.service';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
 export class ApiModule {
@@ -26,8 +28,10 @@ ApiModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2
 ApiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: ApiModule });
 ApiModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiModule, providers: [
         AdvertiserControllerService,
+        AudienceControllerService,
         CampaignControllerService,
-        InsightsControllerService
+        InsightsControllerService,
+        OsMasterControllerService
     ] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiModule, decorators: [{
             type: NgModule,
@@ -37,8 +41,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     exports: [],
                     providers: [
                         AdvertiserControllerService,
+                        AudienceControllerService,
                         CampaignControllerService,
-                        InsightsControllerService
+                        InsightsControllerService,
+                        OsMasterControllerService
                     ]
                 }]
         }], ctorParameters: function () { return [{ type: ApiModule, decorators: [{
@@ -48,4 +54,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 }] }, { type: i1.HttpClient, decorators: [{
                     type: Optional
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2FwaS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBdUIsUUFBUSxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNsRixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFJaEQsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDakYsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDN0UsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7OztBQVc3RSxNQUFNLE9BQU8sU0FBUztJQUNYLE1BQU0sQ0FBQyxPQUFPLENBQUMsb0JBQXlDO1FBQzNELE9BQU87WUFDSCxRQUFRLEVBQUUsU0FBUztZQUNuQixTQUFTLEVBQUUsQ0FBRSxFQUFFLE9BQU8sRUFBRSxhQUFhLEVBQUUsVUFBVSxFQUFFLG9CQUFvQixFQUFFLENBQUU7U0FDOUUsQ0FBQztJQUNOLENBQUM7SUFFRCxZQUFxQyxZQUF1QixFQUNuQyxJQUFnQjtRQUNyQyxJQUFJLFlBQVksRUFBRTtZQUNkLE1BQU0sSUFBSSxLQUFLLENBQUMsa0VBQWtFLENBQUMsQ0FBQztTQUN2RjtRQUNELElBQUksQ0FBQyxJQUFJLEVBQUU7WUFDUCxNQUFNLElBQUksS0FBSyxDQUFDLCtEQUErRDtnQkFDL0UsMERBQTBELENBQUMsQ0FBQztTQUMvRDtJQUNMLENBQUM7O3VHQWpCUSxTQUFTO3dHQUFULFNBQVM7d0dBQVQsU0FBUyxhQUxUO1FBQ1QsMkJBQTJCO1FBQzNCLHlCQUF5QjtRQUN6Qix5QkFBeUI7S0FBRTs0RkFFbEIsU0FBUztrQkFUckIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQU8sRUFBRTtvQkFDaEIsWUFBWSxFQUFFLEVBQUU7b0JBQ2hCLE9BQU8sRUFBTyxFQUFFO29CQUNoQixTQUFTLEVBQUU7d0JBQ1QsMkJBQTJCO3dCQUMzQix5QkFBeUI7d0JBQ3pCLHlCQUF5QjtxQkFBRTtpQkFDOUI7OzBCQVNpQixRQUFROzswQkFBSSxRQUFROzswQkFDcEIsUUFBUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlLCBNb2R1bGVXaXRoUHJvdmlkZXJzLCBTa2lwU2VsZiwgT3B0aW9uYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbmZpZ3VyYXRpb24gfSBmcm9tICcuL2NvbmZpZ3VyYXRpb24nO1xuaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcblxuXG5pbXBvcnQgeyBBZHZlcnRpc2VyQ29udHJvbGxlclNlcnZpY2UgfSBmcm9tICcuL2FwaS9hZHZlcnRpc2VyQ29udHJvbGxlci5zZXJ2aWNlJztcbmltcG9ydCB7IENhbXBhaWduQ29udHJvbGxlclNlcnZpY2UgfSBmcm9tICcuL2FwaS9jYW1wYWlnbkNvbnRyb2xsZXIuc2VydmljZSc7XG5pbXBvcnQgeyBJbnNpZ2h0c0NvbnRyb2xsZXJTZXJ2aWNlIH0gZnJvbSAnLi9hcGkvaW5zaWdodHNDb250cm9sbGVyLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiAgICAgIFtdLFxuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBleHBvcnRzOiAgICAgIFtdLFxuICBwcm92aWRlcnM6IFtcbiAgICBBZHZlcnRpc2VyQ29udHJvbGxlclNlcnZpY2UsXG4gICAgQ2FtcGFpZ25Db250cm9sbGVyU2VydmljZSxcbiAgICBJbnNpZ2h0c0NvbnRyb2xsZXJTZXJ2aWNlIF1cbn0pXG5leHBvcnQgY2xhc3MgQXBpTW9kdWxlIHtcbiAgICBwdWJsaWMgc3RhdGljIGZvclJvb3QoY29uZmlndXJhdGlvbkZhY3Rvcnk6ICgpID0+IENvbmZpZ3VyYXRpb24pOiBNb2R1bGVXaXRoUHJvdmlkZXJzPEFwaU1vZHVsZT4ge1xuICAgICAgICByZXR1cm4ge1xuICAgICAgICAgICAgbmdNb2R1bGU6IEFwaU1vZHVsZSxcbiAgICAgICAgICAgIHByb3ZpZGVyczogWyB7IHByb3ZpZGU6IENvbmZpZ3VyYXRpb24sIHVzZUZhY3Rvcnk6IGNvbmZpZ3VyYXRpb25GYWN0b3J5IH0gXVxuICAgICAgICB9O1xuICAgIH1cblxuICAgIGNvbnN0cnVjdG9yKCBAT3B0aW9uYWwoKSBAU2tpcFNlbGYoKSBwYXJlbnRNb2R1bGU6IEFwaU1vZHVsZSxcbiAgICAgICAgICAgICAgICAgQE9wdGlvbmFsKCkgaHR0cDogSHR0cENsaWVudCkge1xuICAgICAgICBpZiAocGFyZW50TW9kdWxlKSB7XG4gICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ0FwaU1vZHVsZSBpcyBhbHJlYWR5IGxvYWRlZC4gSW1wb3J0IGluIHlvdXIgYmFzZSBBcHBNb2R1bGUgb25seS4nKTtcbiAgICAgICAgfVxuICAgICAgICBpZiAoIWh0dHApIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcignWW91IG5lZWQgdG8gaW1wb3J0IHRoZSBIdHRwQ2xpZW50TW9kdWxlIGluIHlvdXIgQXBwTW9kdWxlISBcXG4nICtcbiAgICAgICAgICAgICdTZWUgYWxzbyBodHRwczovL2dpdGh1Yi5jb20vYW5ndWxhci9hbmd1bGFyL2lzc3Vlcy8yMDU3NScpO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/model/audienceListResponse.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXVkaWVuY2VMaXN0UmVzcG9uc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2RlbC9hdWRpZW5jZUxpc3RSZXNwb25zZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBJbnRlbGxpYmlkIEFQSVxuICogQVBJIGRvY3VtZW50YXRpb24gZm9yIHRoZSBJbnRlbGxpYmlkIHBsYXRmb3JtXG4gKlxuICogT3BlbkFQSSBzcGVjIHZlcnNpb246IDEuMFxuICogXG4gKlxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSB0aGUgc3dhZ2dlciBjb2RlIGdlbmVyYXRvciBwcm9ncmFtLlxuICogaHR0cHM6Ly9naXRodWIuY29tL3N3YWdnZXItYXBpL3N3YWdnZXItY29kZWdlbi5naXRcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgQXVkaWVuY2VSZXNwb25zZURUTyB9IGZyb20gJy4vYXVkaWVuY2VSZXNwb25zZURUTyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQXVkaWVuY2VMaXN0UmVzcG9uc2UgeyBcbiAgICBhdWRpZW5jZXM/OiBBcnJheTxBdWRpZW5jZVJlc3BvbnNlRFRPPjtcbn0iXX0=

package/esm2020/model/audienceResponseDTO.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXVkaWVuY2VSZXNwb25zZURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2F1ZGllbmNlUmVzcG9uc2VEVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogSW50ZWxsaWJpZCBBUElcbiAqIEFQSSBkb2N1bWVudGF0aW9uIGZvciB0aGUgSW50ZWxsaWJpZCBwbGF0Zm9ybVxuICpcbiAqIE9wZW5BUEkgc3BlYyB2ZXJzaW9uOiAxLjBcbiAqIFxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgdGhlIHN3YWdnZXIgY29kZSBnZW5lcmF0b3IgcHJvZ3JhbS5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9zd2FnZ2VyLWFwaS9zd2FnZ2VyLWNvZGVnZW4uZ2l0XG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXG4gKi9cbmltcG9ydCB7IENvbmZpZ0l0ZW1EVE8gfSBmcm9tICcuL2NvbmZpZ0l0ZW1EVE8nO1xuXG5leHBvcnQgaW50ZXJmYWNlIEF1ZGllbmNlUmVzcG9uc2VEVE8geyBcbiAgICBhdWRpZW5jZUlkPzogbnVtYmVyO1xuICAgIGF1ZGllbmNlTmFtZT86IHN0cmluZztcbiAgICBhdWRpZW5jZVR5cGU/OiBzdHJpbmc7XG4gICAgcGxhdGZvcm1BdWRpZW5jZUlkPzogc3RyaW5nO1xuICAgIGNyZWF0ZWRBdD86IHN0cmluZztcbiAgICBjb25maWdzPzogQXJyYXk8Q29uZmlnSXRlbURUTz47XG59Il19

package/esm2020/model/campaignRequest.mjs

@@ -25,14 +25,9 @@ export var CampaignRequest;
         COSTPERRESULT: 'COST_PER_RESULT',
         ROAS: 'ROAS'
     };
-    CampaignRequest.OsEnum = {
-        ANDROID: 'ANDROID',
-        IOS: 'IOS',
-        UNKNOWN: 'UNKNOWN'
-    };
     CampaignRequest.MmpAttributionSettingEnum = {
         CTA: 'CTA',
         CTAANDVTA: 'CTA_AND_VTA'
     };
 })(CampaignRequest || (CampaignRequest = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/model/campaignResponse.mjs

@@ -14,14 +14,9 @@ export var CampaignResponse;
         COSTPERRESULT: 'COST_PER_RESULT',
         ROAS: 'ROAS'
     };
-    CampaignResponse.OsEnum = {
-        ANDROID: 'ANDROID',
-        IOS: 'IOS',
-        UNKNOWN: 'UNKNOWN'
-    };
     CampaignResponse.MmpAttributionSettingEnum = {
         CTA: 'CTA',
         CTAANDVTA: 'CTA_AND_VTA'
     };
 })(CampaignResponse || (CampaignResponse = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/model/configItemDTO.mjs

@@ -0,0 +1,13 @@
+/**
+ * Intellibid API
+ * API documentation for the Intellibid platform
+ *
+ * OpenAPI spec version: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnSXRlbURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2NvbmZpZ0l0ZW1EVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7R0FVRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogSW50ZWxsaWJpZCBBUElcbiAqIEFQSSBkb2N1bWVudGF0aW9uIGZvciB0aGUgSW50ZWxsaWJpZCBwbGF0Zm9ybVxuICpcbiAqIE9wZW5BUEkgc3BlYyB2ZXJzaW9uOiAxLjBcbiAqIFxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgdGhlIHN3YWdnZXIgY29kZSBnZW5lcmF0b3IgcHJvZ3JhbS5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9zd2FnZ2VyLWFwaS9zd2FnZ2VyLWNvZGVnZW4uZ2l0XG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBDb25maWdJdGVtRFRPIHsgXG4gICAga2V5Pzogc3RyaW5nO1xuICAgIHZhbHVlPzogc3RyaW5nO1xufSJdfQ==

package/esm2020/model/createBlockedAudienceRequest.mjs

@@ -0,0 +1,21 @@
+/**
+ * Intellibid API
+ * API documentation for the Intellibid platform
+ *
+ * OpenAPI spec version: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+export var CreateBlockedAudienceRequest;
+(function (CreateBlockedAudienceRequest) {
+    CreateBlockedAudienceRequest.SourcePlatformEnum = {
+        META: 'META',
+        TIKTOK: 'TIKTOK',
+        GOOGLE: 'GOOGLE',
+        SNAPCHAT: 'SNAPCHAT'
+    };
+})(CreateBlockedAudienceRequest || (CreateBlockedAudienceRequest = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlQmxvY2tlZEF1ZGllbmNlUmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2NyZWF0ZUJsb2NrZWRBdWRpZW5jZVJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7R0FVRztBQU1ILE1BQU0sS0FBVyw0QkFBNEIsQ0FRNUM7QUFSRCxXQUFpQiw0QkFBNEI7SUFFNUIsK0NBQWtCLEdBQUc7UUFDOUIsSUFBSSxFQUFFLE1BQTRCO1FBQ2xDLE1BQU0sRUFBRSxRQUE4QjtRQUN0QyxNQUFNLEVBQUUsUUFBOEI7UUFDdEMsUUFBUSxFQUFFLFVBQWdDO0tBQzdDLENBQUM7QUFDTixDQUFDLEVBUmdCLDRCQUE0QixLQUE1Qiw0QkFBNEIsUUFRNUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEludGVsbGliaWQgQVBJXG4gKiBBUEkgZG9jdW1lbnRhdGlvbiBmb3IgdGhlIEludGVsbGliaWQgcGxhdGZvcm1cbiAqXG4gKiBPcGVuQVBJIHNwZWMgdmVyc2lvbjogMS4wXG4gKiBcbiAqXG4gKiBOT1RFOiBUaGlzIGNsYXNzIGlzIGF1dG8gZ2VuZXJhdGVkIGJ5IHRoZSBzd2FnZ2VyIGNvZGUgZ2VuZXJhdG9yIHByb2dyYW0uXG4gKiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuLmdpdFxuICogRG8gbm90IGVkaXQgdGhlIGNsYXNzIG1hbnVhbGx5LlxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3JlYXRlQmxvY2tlZEF1ZGllbmNlUmVxdWVzdCB7IFxuICAgIGFkdmVydGlzZXJJZDogbnVtYmVyO1xuICAgIHNvdXJjZVBsYXRmb3JtOiBDcmVhdGVCbG9ja2VkQXVkaWVuY2VSZXF1ZXN0LlNvdXJjZVBsYXRmb3JtRW51bTtcbn1cbmV4cG9ydCBuYW1lc3BhY2UgQ3JlYXRlQmxvY2tlZEF1ZGllbmNlUmVxdWVzdCB7XG4gICAgZXhwb3J0IHR5cGUgU291cmNlUGxhdGZvcm1FbnVtID0gJ01FVEEnIHwgJ1RJS1RPSycgfCAnR09PR0xFJyB8ICdTTkFQQ0hBVCc7XG4gICAgZXhwb3J0IGNvbnN0IFNvdXJjZVBsYXRmb3JtRW51bSA9IHtcbiAgICAgICAgTUVUQTogJ01FVEEnIGFzIFNvdXJjZVBsYXRmb3JtRW51bSxcbiAgICAgICAgVElLVE9LOiAnVElLVE9LJyBhcyBTb3VyY2VQbGF0Zm9ybUVudW0sXG4gICAgICAgIEdPT0dMRTogJ0dPT0dMRScgYXMgU291cmNlUGxhdGZvcm1FbnVtLFxuICAgICAgICBTTkFQQ0hBVDogJ1NOQVBDSEFUJyBhcyBTb3VyY2VQbGF0Zm9ybUVudW1cbiAgICB9O1xufSJdfQ==