@drttix/drt-sdk 0.2.2 → 0.2.4

package/src/generated/portal/models/LandingPageResponseDto.ts

@@ -0,0 +1,28 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { TemplateResponseDto } from './TemplateResponseDto';
+export type LandingPageResponseDto = {
+    body: string;
+    title: string;
+    albumId: Record<string, any>;
+    dateShowShowsAfter: string;
+    facebookAlbumId: number;
+    isActive: number;
+    listShows: number;
+    showEmail: number;
+    showEndDates: number;
+    showEndedSalesShows: number;
+    showLogo: number;
+    showOpenDates: number;
+    showPriorityDates: number;
+    showProducts: number;
+    showVenueName: number;
+    showSeatCounts: number;
+    showVenueAddress: number;
+    showVenueMap: number;
+    facebookId: number;
+    templates: Array<TemplateResponseDto>;
+};
+

package/src/generated/portal/models/PolicyDto.ts

@@ -4,6 +4,6 @@
 /* eslint-disable */
 export type PolicyDto = {
     id: number;
-    value: number;
+    value: string;
 };
 

package/src/generated/portal/models/ProductDetailResponseDto.ts

@@ -0,0 +1,35 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ProductDetailResponseDto = {
+    name: string;
+    cost: number;
+    description: string;
+    fee: number;
+    price: number;
+    rank: number;
+    isActive: number;
+    salesTax: number;
+    qtyAvailable: number;
+    deliveryMethod: string;
+    deliverableHref: string;
+    deliverableHrefDateAvailable: string;
+    deliverableHrefDateUnavailable: string;
+    dateAvailable: string;
+    dateHideAfter: string;
+    onlineOnly: number;
+    availableAtDoor: number;
+    availableAtStudio: number;
+    partOfRecitalPackage: number;
+    requiresShipping: number;
+    iconId: number;
+    customTextName: string;
+    customTextMaxLength: number;
+    customTextRequired: number;
+    customTextExample: string;
+    noDefaultOption: number;
+    showGroupId: number;
+    imageUrl: string;
+};
+

package/src/generated/portal/models/ReorderImageRequestDto.ts

@@ -0,0 +1,8 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ReorderImageRequestDto = {
+    body: Array<string>;
+};
+

package/src/generated/portal/models/SettingsDetailsResponseDto.ts

@@ -50,6 +50,7 @@ export type SettingsDetailsResponseDto = {
     isTaxExempt: number;
     paymentGatewayId: number;
     disableTicketsForUnsold: number;
+    hideStudioAddress: number;
     timezoneList: Array<TimeZoneResponse>;
 };
 

package/src/generated/portal/models/TemplateResponseDto.ts

@@ -0,0 +1,9 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type TemplateResponseDto = {
+    id: number;
+    saveName: string;
+};
+

package/src/generated/portal/models/ThemeBannerImageResponseDto.ts

@@ -0,0 +1,11 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ThemeBannerImageResponseDto = {
+    id: number;
+    src: string;
+    clouded: number;
+    dateCreated: string;
+};
+

package/src/generated/portal/models/ThemeDesignResponseDto.ts

@@ -0,0 +1,37 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ThemeDesignResponseDto = {
+    id: number;
+    name: string;
+    bodyBackgroundColor: string;
+    bodyBackgroundFadeBottom: string;
+    bodyBackgroundFadeTop: string;
+    bodyBackgroundSrc: string;
+    bodyBackgroundType: string;
+    color1: string;
+    color1text: string;
+    color2: string;
+    color2text: string;
+    colorNeutral: string;
+    colorNeutralText: string;
+    headerHeight: string;
+    headerBackgroundColor: string;
+    headerBackgroundSrc: string;
+    headerBackgroundType: string;
+    headerSubtextSize: string;
+    headerTextColor: string;
+    headerTextDisplay: string;
+    headerTextMaxWidth: string;
+    headerTextRight: string;
+    headerTextSize: string;
+    headerTextTop: string;
+    headerTextWeight: string;
+    logoDisplay: string;
+    logoLeft: string;
+    logoMaxHeight: string;
+    logoMaxWidth: string;
+    logoTop: string;
+};
+

package/src/generated/portal/models/UpdateImageUploadRequestDto.ts

@@ -4,5 +4,7 @@
 /* eslint-disable */
 export type UpdateImageUploadRequestDto = {
     url: string;
+    originalFileName: string;
+    serverFileName: string;
 };
 

package/src/generated/portal/models/UpdateLandingPageConfigSettingRequestDto.ts

@@ -0,0 +1,23 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type UpdateLandingPageConfigSettingRequestDto = {
+    listShows: number;
+    showPriorityDates: number;
+    showOpenDates: number;
+    showEndDates: number;
+    showLogo: number;
+    showVenueName: number;
+    showVenueAddress: number;
+    showVenueMap: number;
+    showSeatCounts: number;
+    showEndedSalesShows: number;
+    showEmail: number;
+    dateShowShowsAfter: string;
+    showProducts: number;
+    productsIncludeFee: number;
+    isActive: number;
+    showDateOnLanding: string;
+};
+

package/src/generated/portal/models/UpdateLandingPageRequestDto.ts

@@ -0,0 +1,13 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type UpdateLandingPageRequestDto = {
+    title: string;
+    body: string;
+    facebookAlbumId: number;
+    albumId: number;
+    isActive: number;
+    facebookId: number;
+};
+

package/src/generated/portal/models/UpdateThemeDesignRequestDto.ts

@@ -0,0 +1,32 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type UpdateThemeDesignRequestDto = {
+    bodyBackgroundType: string;
+    bodyBackgroundFadeTop: string;
+    bodyBackgroundFadeBottom: string;
+    bodyBackgroundColor: string;
+    bodyBackgroundSrc: string;
+    headerHeight: string;
+    headerBackgroundType: string;
+    headerBackgroundColor: string;
+    headerBackgroundSrc: string;
+    headerTextDisplay: string;
+    headerTextSize: string;
+    headerTextMaxWidth: string;
+    headerTextTop: string;
+    headerTextRight: string;
+    headerTextColor: string;
+    headerSubtextSize: string;
+    logoDisplay: string;
+    logoTop: string;
+    logoLeft: string;
+    logoMaxWidth: string;
+    logoMaxHeight: string;
+    color1: string;
+    color1text: string;
+    color2: string;
+    color2text: string;
+};
+

package/src/generated/portal/services/ClientToolsThemeBuilderService.ts

@@ -0,0 +1,149 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { StartImageUploadRequestDto } from '../models/StartImageUploadRequestDto';
+import type { StartImageUploadResponseDto } from '../models/StartImageUploadResponseDto';
+import type { SuccessResponse } from '../models/SuccessResponse';
+import type { ThemeBannerImageResponseDto } from '../models/ThemeBannerImageResponseDto';
+import type { ThemeDesignResponseDto } from '../models/ThemeDesignResponseDto';
+import type { UpdateImageUploadRequestDto } from '../models/UpdateImageUploadRequestDto';
+import type { UpdateThemeDesignRequestDto } from '../models/UpdateThemeDesignRequestDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ClientToolsThemeBuilderService {
+    /**
+     * Fetch the studio design
+     * Fetch the studio design
+     * @param xStudioId The ID of the studio
+     * @returns ThemeDesignResponseDto Studio design fetched successfully
+     * @throws ApiError
+     */
+    public static getStudioDesign(
+        xStudioId: string,
+    ): CancelablePromise<ThemeDesignResponseDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/client-tools/theme-builder/studio-design',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Update the studio design
+     * Update the studio design
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to update the studio design
+     * @returns SuccessResponse Studio design updated successfully
+     * @throws ApiError
+     */
+    public static updateStudioDesign(
+        xStudioId: string,
+        requestBody: UpdateThemeDesignRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/client-tools/theme-builder/studio-design',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Fetch the studio assigned images
+     * Fetch the studio assigned images
+     * @param xStudioId The ID of the studio
+     * @param format
+     * @param library
+     * @param minWidth
+     * @param maxWidth
+     * @param minHeight
+     * @param maxHeight
+     * @returns ThemeBannerImageResponseDto Images fetched successfully
+     * @throws ApiError
+     */
+    public static getStudioImages(
+        xStudioId: string,
+        format: string,
+        library: string,
+        minWidth: number,
+        maxWidth: number,
+        minHeight: number,
+        maxHeight: number,
+    ): CancelablePromise<Array<ThemeBannerImageResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/client-tools/theme-builder/images',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            query: {
+                'format': format,
+                'library': library,
+                'minWidth': minWidth,
+                'maxWidth': maxWidth,
+                'minHeight': minHeight,
+                'maxHeight': maxHeight,
+            },
+        });
+    }
+    /**
+     * Start image upload
+     * Start a new image upload for the given studio ID
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to start image upload
+     * @returns StartImageUploadResponseDto Image upload started successfully
+     * @throws ApiError
+     */
+    public static startImageUpload(
+        xStudioId: string,
+        requestBody: StartImageUploadRequestDto,
+    ): CancelablePromise<StartImageUploadResponseDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/client-tools/theme-builder/start-image-upload',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update image url for the album
+     * Update image url for the given album ID
+     * @param xStudioId The ID of the studio
+     * @param format
+     * @param width
+     * @param height
+     * @param requestBody Payload to update image url for album
+     * @returns SuccessResponse Image url updated successfully
+     * @throws ApiError
+     */
+    public static updateImageUrl(
+        xStudioId: string,
+        format: string,
+        width: number,
+        height: number,
+        requestBody: UpdateImageUploadRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/client-tools/theme-builder/update-image-url',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            query: {
+                'format': format,
+                'width': width,
+                'height': height,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}

package/src/generated/portal/services/FeaturesLandingPageService.ts

@@ -0,0 +1,299 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AlbumImageResponseDto } from '../models/AlbumImageResponseDto';
+import type { CreateUpdateAlbumRequestDto } from '../models/CreateUpdateAlbumRequestDto';
+import type { DeleteAlbumImageRequestDto } from '../models/DeleteAlbumImageRequestDto';
+import type { LandingPageAlbumResponseDto } from '../models/LandingPageAlbumResponseDto';
+import type { LandingPageResponseDto } from '../models/LandingPageResponseDto';
+import type { ReorderImageRequestDto } from '../models/ReorderImageRequestDto';
+import type { StartImageUploadRequestDto } from '../models/StartImageUploadRequestDto';
+import type { StartImageUploadResponseDto } from '../models/StartImageUploadResponseDto';
+import type { SuccessResponse } from '../models/SuccessResponse';
+import type { UpdateImageUploadRequestDto } from '../models/UpdateImageUploadRequestDto';
+import type { UpdateLandingPageConfigSettingRequestDto } from '../models/UpdateLandingPageConfigSettingRequestDto';
+import type { UpdateLandingPageRequestDto } from '../models/UpdateLandingPageRequestDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class FeaturesLandingPageService {
+    /**
+     * Fetch the Landing Page details
+     * Fetch the Landing Page details
+     * @param xStudioId The ID of the studio
+     * @returns LandingPageResponseDto Landing Page details fetched successfully
+     * @throws ApiError
+     */
+    public static getLandingPage(
+        xStudioId: string,
+    ): CancelablePromise<LandingPageResponseDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/landing-page',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Update the Landing Page details
+     * Update the Landing Page details
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to update Landing Page details
+     * @returns SuccessResponse Landing Page details updated successfully
+     * @throws ApiError
+     */
+    public static updateLandingPageSettings(
+        xStudioId: string,
+        requestBody: UpdateLandingPageRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/features/landing-page',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Fetch the album details
+     * Fetch the album details
+     * @param xStudioId The ID of the studio
+     * @returns LandingPageAlbumResponseDto Albums fetched successfully
+     * @throws ApiError
+     */
+    public static getAlbums(
+        xStudioId: string,
+    ): CancelablePromise<Array<LandingPageAlbumResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/landing-page/albums',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Fetch the album images
+     * Fetch the album images
+     * @param xStudioId The ID of the studio
+     * @param albumId The ID of the album
+     * @returns AlbumImageResponseDto Albums images fetched successfully
+     * @throws ApiError
+     */
+    public static getAlbumImages(
+        xStudioId: string,
+        albumId: string,
+    ): CancelablePromise<Array<AlbumImageResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/features/landing-page/{albumId}/images',
+            path: {
+                'albumId': albumId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Delete the album images
+     * Delete the album images
+     * @param xStudioId The ID of the studio
+     * @param albumId
+     * @param requestBody
+     * @returns SuccessResponse Album images deleted successfully
+     * @throws ApiError
+     */
+    public static deleteAlbumImages(
+        xStudioId: string,
+        albumId: string,
+        requestBody: DeleteAlbumImageRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/features/landing-page/{albumId}/images',
+            path: {
+                'albumId': albumId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Create a new album
+     * Create a new album
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to create a new album
+     * @returns number Album created successfully
+     * @throws ApiError
+     */
+    public static createAlbum(
+        xStudioId: string,
+        requestBody: CreateUpdateAlbumRequestDto,
+    ): CancelablePromise<number> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/landing-page/album',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update the image order
+     * Update the image order
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to update image order
+     * @returns SuccessResponse Image order updated successfully
+     * @throws ApiError
+     */
+    public static updateImageOrder(
+        xStudioId: string,
+        requestBody: ReorderImageRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/landing-page/reorder-images',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Start image upload
+     * Start a new image upload for the given studio ID
+     * @param albumId The ID of the album
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to start image upload
+     * @returns StartImageUploadResponseDto Image upload started successfully
+     * @throws ApiError
+     */
+    public static startImageUpload(
+        albumId: string,
+        xStudioId: string,
+        requestBody: StartImageUploadRequestDto,
+    ): CancelablePromise<StartImageUploadResponseDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/landing-page/{albumId}/start-image-upload',
+            path: {
+                'albumId': albumId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update image url for the album
+     * Update image url for the given album ID
+     * @param xStudioId The ID of the studio
+     * @param albumId The ID of the album
+     * @param requestBody Payload to update image url for album
+     * @returns SuccessResponse Image url updated successfully
+     * @throws ApiError
+     */
+    public static updateImageUrl(
+        xStudioId: string,
+        albumId: string,
+        requestBody: UpdateImageUploadRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/features/landing-page/{albumId}/update-image-url',
+            path: {
+                'albumId': albumId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update the Landing Page settings
+     * Update the Landing Page settings
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to update Landing Page settings
+     * @returns SuccessResponse Landing Page settings updated successfully
+     * @throws ApiError
+     */
+    public static updateLandingPageSettings1(
+        xStudioId: string,
+        requestBody: UpdateLandingPageConfigSettingRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/features/landing-page/settings',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Update the album
+     * Update the album
+     * @param albumId
+     * @param xStudioId The ID of the studio
+     * @param requestBody Payload to update Landing Page settings
+     * @returns SuccessResponse Album updated successfully
+     * @throws ApiError
+     */
+    public static updateAlbum(
+        albumId: string,
+        xStudioId: string,
+        requestBody: CreateUpdateAlbumRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/features/landing-page/{albumId}',
+            path: {
+                'albumId': albumId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Delete the album
+     * Delete the album
+     * @param albumId
+     * @param xStudioId The ID of the studio
+     * @returns SuccessResponse Album deleted successfully
+     * @throws ApiError
+     */
+    public static deleteAlbum(
+        albumId: string,
+        xStudioId: string,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/features/landing-page/{albumId}',
+            path: {
+                'albumId': albumId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+}