@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/marketingService/services/MarketingCampaignsService.ts

@@ -0,0 +1,193 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Int32Envelope } from '../models/Int32Envelope';
+import type { MarketingCampaignCreateDto } from '../models/MarketingCampaignCreateDto';
+import type { MarketingCampaignDtoEnvelope } from '../models/MarketingCampaignDtoEnvelope';
+import type { MarketingCampaignUpdateDto } from '../models/MarketingCampaignUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class MarketingCampaignsService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns void
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceMarketingCampaigns(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/MarketingCampaigns',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2MarketingServiceMarketingCampaigns(
+        tenantId: string,
+        requestBody: MarketingCampaignCreateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/MarketingService/MarketingCampaigns',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceMarketingCampaignsCount(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/MarketingCampaigns/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param marketingcampaignId
+     * @param xApiVersion
+     * @returns MarketingCampaignDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceMarketingCampaigns1(
+        tenantId: string,
+        marketingcampaignId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<MarketingCampaignDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/MarketingCampaigns/{marketingcampaignId}',
+            path: {
+                'marketingcampaignId': marketingcampaignId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param marketingcampaignId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2MarketingServiceMarketingCampaigns(
+        tenantId: string,
+        marketingcampaignId: string,
+        requestBody: MarketingCampaignUpdateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/MarketingService/MarketingCampaigns/{marketingcampaignId}',
+            path: {
+                'marketingcampaignId': marketingcampaignId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param marketingcampaignId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2MarketingServiceMarketingCampaigns(
+        tenantId: string,
+        marketingcampaignId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/MarketingService/MarketingCampaigns/{marketingcampaignId}',
+            path: {
+                'marketingcampaignId': marketingcampaignId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/marketingService/services/MarketingListsService.ts

@@ -0,0 +1,193 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Int32Envelope } from '../models/Int32Envelope';
+import type { MarketingListCreateDto } from '../models/MarketingListCreateDto';
+import type { MarketingListDtoEnvelope } from '../models/MarketingListDtoEnvelope';
+import type { MarketingListDtoListEnvelope } from '../models/MarketingListDtoListEnvelope';
+import type { MarketingListUpdateDto } from '../models/MarketingListUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class MarketingListsService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns MarketingListDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceMarketingLists(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<MarketingListDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/MarketingLists',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2MarketingServiceMarketingLists(
+        tenantId: string,
+        requestBody: MarketingListCreateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/MarketingService/MarketingLists',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceMarketingListsCount(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/MarketingLists/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param marketinglistId
+     * @param xApiVersion
+     * @returns MarketingListDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceMarketingLists1(
+        tenantId: string,
+        marketinglistId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<MarketingListDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/MarketingLists/{marketinglistId}',
+            path: {
+                'marketinglistId': marketinglistId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param marketinglistId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2MarketingServiceMarketingLists(
+        tenantId: string,
+        marketinglistId: string,
+        requestBody: MarketingListUpdateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/MarketingService/MarketingLists/{marketinglistId}',
+            path: {
+                'marketinglistId': marketinglistId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param marketinglistId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2MarketingServiceMarketingLists(
+        tenantId: string,
+        marketinglistId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/MarketingService/MarketingLists/{marketinglistId}',
+            path: {
+                'marketinglistId': marketinglistId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/marketingService/services/NewslettersService.ts

@@ -0,0 +1,193 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Int32Envelope } from '../models/Int32Envelope';
+import type { NewsletterCreateDto } from '../models/NewsletterCreateDto';
+import type { NewsletterDtoEnvelope } from '../models/NewsletterDtoEnvelope';
+import type { NewsletterUpdateDto } from '../models/NewsletterUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class NewslettersService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns void
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceNewsletters(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/Newsletters',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2MarketingServiceNewsletters(
+        tenantId: string,
+        requestBody: NewsletterCreateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/MarketingService/Newsletters',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceNewslettersCount(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/Newsletters/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param newsletterId
+     * @param xApiVersion
+     * @returns NewsletterDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MarketingServiceNewsletters1(
+        tenantId: string,
+        newsletterId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<NewsletterDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/MarketingService/Newsletters/{newsletterId}',
+            path: {
+                'newsletterId': newsletterId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param newsletterId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2MarketingServiceNewsletters(
+        tenantId: string,
+        newsletterId: string,
+        requestBody: NewsletterUpdateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/MarketingService/Newsletters/{newsletterId}',
+            path: {
+                'newsletterId': newsletterId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param newsletterId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2MarketingServiceNewsletters(
+        tenantId: string,
+        newsletterId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/MarketingService/Newsletters/{newsletterId}',
+            path: {
+                'newsletterId': newsletterId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}