@dalmore/api-contracts 1.0.2 → 1.0.5

package/contracts/compliance/site-settings/index.ts

@@ -1,669 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  GetSiteDomainZod,
-  InternalError,
-  UnauthorizedError,
-  PatchSiteDomainResponse,
-  GetSeoSettingsZod,
-  PatchSeoSettingsZod,
-  GetBrandingSettingsZod,
-  PatchBrandingSettingsZod,
-  ITheme,
-  themeIdSchema,
-  themeSettingIdSchema,
-  IThemeSetting,
-  ThemesList,
-  IThemeSettings,
-  GetPasswordProtectionSettingsZod,
-  PatchPasswordProtectionSettingsZod,
-  ImportThemeSettingsZod,
-  ExportThemeSettingsZod,
-  accountIdSchema,
-  ThemeFiltersZod,
-  UpdateWithPersonaThemeIdZod,
-  GetEmailSettingsZod,
-  CompliancePatchEmailSettingsZod,
-  ComplianceUpdateGaIdZod,
-  GetInvestorAccountTypeSettingsZod,
-  CompliancePatchInvestorAccountTypeSettingsZod,
-  GetSynchronizeThemeBlobsZod,
-  PatchSiteDomainZod,
-  GetSenderEmailZod,
-  CompliancePatchSenderEmailZod,
-  GetCurrentLandingPageZod,
-  CompliancePatchCurrentLandingPageZod,
-  GetPixelCodeZod,
-  CompliancePatchPixelCodeZod,
-  GetDemoCredentialsZod,
-  ComplianceUpdateDemoPassword,
-  GetPublicDataTypesZod,
-  CompliancePatchPublicDataTypesZod,
-  GetThemesAdminQuery,
-  PaginationOptionsZod,
-  CompliancePostThemeZod,
-  CompliancePatchThemeSetting,
-  CompliancePatchThemeSettings,
-  GetDefaultThemesZod,
-  CompliancePatchThemeNameZod,
-} from '../../../common/types';
-import { z } from 'zod';
-import { SiteZod } from '../../../common/types/site.types';
-
-const c = initContract();
-
-export const siteSettingsContract = c.router(
-  {
-    getPasswordProtectionSettings: {
-      summary: 'Get the password protection settings for the current account',
-      method: 'GET',
-      path: '/password-protection/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetPasswordProtectionSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updatePasswordProtectionSettings: {
-      summary:
-        'Update the password protection settings for the current account',
-      method: 'PATCH',
-      path: '/password-protection/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      body: PatchPasswordProtectionSettingsZod,
-      responses: {
-        201: GetPasswordProtectionSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDomainSettings: {
-      summary: 'Get the domain for the current issuer',
-      method: 'GET',
-      path: '/domains/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetSiteDomainZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateDomainSettings: {
-      summary: 'Update the domain for the current issuer',
-      method: 'PATCH',
-      path: '/domains/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      body: PatchSiteDomainZod,
-      responses: {
-        201: PatchSiteDomainResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getInvestorAccountTypeSettings: {
-      summary: 'Get the investor account type settings for the current account',
-      method: 'GET',
-      path: '/investor-account-types/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetInvestorAccountTypeSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateInvestorAccountTypeSettings: {
-      summary:
-        'Update the investor account type settings for the current account',
-      method: 'PATCH',
-      path: '/investor-account-types',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchInvestorAccountTypeSettingsZod,
-      responses: {
-        201: GetInvestorAccountTypeSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    getSeoSettings: {
-      summary: 'Get the seo settings for the current account',
-      method: 'GET',
-      path: '/seo/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetSeoSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateSeoSettings: {
-      summary: 'Update the seo settings for the current account',
-      method: 'PATCH',
-      path: '/seo/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      body: PatchSeoSettingsZod,
-      responses: {
-        201: GetSeoSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getBrandingSettings: {
-      summary: 'Get the branding setting for the current account',
-      method: 'GET',
-      path: '/branding/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetBrandingSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateBrandingSettings: {
-      summary: 'Update the branding settings for the current account',
-      method: 'PATCH',
-      path: '/branding/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      body: PatchBrandingSettingsZod,
-      responses: {
-        201: GetBrandingSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getEmailSettings: {
-      summary: 'Get the email setting for the specified account',
-      method: 'GET',
-      path: '/email/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetEmailSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateEmailSettings: {
-      summary: 'Update the email settings for the specified account',
-      method: 'PATCH',
-      path: '/email',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchEmailSettingsZod,
-      responses: {
-        201: GetEmailSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getThemesAdmin: {
-      summary: '[ADMIN] Get the themes for the admin users',
-      method: 'GET',
-      path: '/themes/admin',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(GetThemesAdminQuery),
-      responses: {
-        200: ThemesList,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getThemes: {
-      summary: 'Get the themes for the current account',
-      method: 'GET',
-      path: '/themes/account/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: ThemesList,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getTheme: {
-      summary: 'Get the themes for the current account',
-      method: 'GET',
-      path: '/themes/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeIdSchema,
-      }),
-      query: z.object({}).merge(ThemeFiltersZod),
-      responses: {
-        200: ITheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    postTheme: {
-      summary: 'Post a theme',
-      method: 'POST',
-      path: '/themes',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostThemeZod,
-      responses: {
-        201: ITheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    patchThemeSettings: {
-      summary: 'Patch theme settings',
-      method: 'PATCH',
-      path: '/themes/:id/theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeIdSchema,
-      }),
-      body: CompliancePatchThemeSettings,
-      responses: {
-        201: IThemeSettings,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchThemeSetting: {
-      summary: 'Patch a theme setting',
-      method: 'PATCH',
-      path: '/themes/:themeId/theme-settings/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeSettingIdSchema,
-        themeId: themeIdSchema,
-      }),
-      body: CompliancePatchThemeSetting,
-      responses: {
-        201: IThemeSetting,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    importThemeSettings: {
-      summary: 'Import theme settings',
-      method: 'POST',
-      path: '/themes/:id/import-theme-settings/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeIdSchema,
-        accountId: accountIdSchema,
-      }),
-      body: ImportThemeSettingsZod,
-      responses: {
-        201: IThemeSettings,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    exportThemeSettings: {
-      summary: 'Export theme settings',
-      method: 'GET',
-      path: '/themes/:id/export-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeIdSchema,
-      }),
-      responses: {
-        200: ExportThemeSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchThemeName: {
-      summary: 'Patch the name of a theme',
-      method: 'PATCH',
-      path: '/themes/:id/name',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeIdSchema,
-      }),
-      body: CompliancePatchThemeNameZod,
-      responses: {
-        201: ITheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updateWithPersonaThemeId: {
-      summary: 'Update the with persona theme id for the current account',
-      method: 'PATCH',
-      path: '/with-persona-theme/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      body: UpdateWithPersonaThemeIdZod,
-      responses: {
-        201: SiteZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updateGaId: {
-      summary: 'Update the GA ID for the current account',
-      method: 'PATCH',
-      path: '/ga-id',
-      metadata: {
-        auth: true,
-      },
-      body: ComplianceUpdateGaIdZod,
-      responses: {
-        201: SiteZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getSenderEmail: {
-      summary: '[ADMIN] Get the sender email for the current account',
-      method: 'GET',
-      path: '/sender-email/:accountId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetSenderEmailZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchSenderEmail: {
-      summary: '[ADMIN] Patch the sender email for the current account',
-      method: 'PATCH',
-      path: '/sender-email',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchSenderEmailZod,
-      responses: {
-        201: GetSenderEmailZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getCurrentLandingPage: {
-      summary: '[Admin] Get the current landing page for the account',
-      method: 'GET',
-      path: '/landing-page',
-      query: z.object({
-        accountId: accountIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetCurrentLandingPageZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchCurrentLandingPage: {
-      summary: '[Admin] Update the current landing page for the account',
-      method: 'PATCH',
-      path: '/landing-page',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchCurrentLandingPageZod,
-      responses: {
-        201: GetCurrentLandingPageZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPixelCode: {
-      summary: '[Admin] Get the pixel code for the current account',
-      method: 'GET',
-      path: '/pixel-code',
-      query: z.object({
-        accountId: accountIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetPixelCodeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchPixelCode: {
-      summary: '[Admin] Update the pixel code for the current account',
-      method: 'PATCH',
-      path: '/pixel-code',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchPixelCodeZod,
-      responses: {
-        201: GetPixelCodeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    synchronizeThemeBlobs: {
-      summary: '[ADMIN] Synchronize the theme blobs for all accounts',
-      method: 'GET',
-      path: '/synchronize-theme-blobs',
-      metadata: {
-        auth: true,
-      },
-      query: GetSynchronizeThemeBlobsZod,
-      responses: {
-        200: PatchSiteDomainResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDemoCredentials: {
-      summary: 'Get the demo credentials for the current account',
-      method: 'GET',
-      path: '/demo-credentials',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetDemoCredentialsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchDemoCredentials: {
-      summary: 'Update the demo credentials for the current account',
-      method: 'PATCH',
-      path: '/demo-credentials',
-      metadata: {
-        auth: true,
-      },
-      body: ComplianceUpdateDemoPassword,
-      responses: {
-        201: GetDemoCredentialsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPublicDataTypes: {
-      summary: '[Admin] Get the public data types for the current account',
-      method: 'GET',
-      path: '/public-data-types',
-      query: z.object({
-        accountId: accountIdSchema,
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetPublicDataTypesZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchPublicDataTypes: {
-      summary: '[Admin] Update the public data types for the current account',
-      method: 'PATCH',
-      path: '/public-data-types',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePatchPublicDataTypesZod,
-      responses: {
-        201: GetPublicDataTypesZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDefaultThemes: {
-      summary: '[ADMIN] Get the default themes',
-      method: 'GET',
-      path: '/default-themes',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetDefaultThemesZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'site-settings',
-  },
-);

package/contracts/compliance/sites/index.ts

@@ -1,56 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  SitesFiltersZod,
-  SitesIncludeQuery,
-  SitesPaginated,
-  SitesParamSchema,
-  SiteZod,
-} from '../../../common/types/site.types';
-
-const c = initContract();
-
-export const sitesContract = c.router(
-  {
-    getSite: {
-      summary: 'get site by id',
-      method: 'GET',
-      path: '/:id',
-      pathParams: SitesParamSchema,
-      metadata: {
-        auth: true,
-      },
-      query: SitesIncludeQuery.merge(SitesFiltersZod),
-      responses: {
-        200: SiteZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getSites: {
-      summary: 'query sites by url ',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(SitesFiltersZod).merge(SitesIncludeQuery),
-      responses: {
-        200: SitesPaginated,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'sites',
-  },
-);