@dalmore/api-contracts 0.0.0-dev.988f3c3 → 0.0.0-dev.9c066a6

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

@@ -1,585 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PatchSiteDomainZod,
-  GetSiteDomainZod,
-  InternalError,
-  UnauthorizedError,
-  PatchSiteDomainResponse,
-  GetSeoSettingsZod,
-  PatchSeoSettingsZod,
-  GetBrandingSettingsZod,
-  PatchBrandingSettingsZod,
-  PaginationOptionsZod,
-  PostThemeZod,
-  ITheme,
-  themeIdSchema,
-  themeSettingIdSchema,
-  IThemeSetting,
-  ThemesList,
-  PatchThemeSetting,
-  PatchThemeSettings,
-  IThemeSettings,
-  GetPasswordProtectionSettingsZod,
-  PatchPasswordProtectionSettingsZod,
-  ImportThemeSettingsZod,
-  ExportThemeSettingsZod,
-  PatchThemeNameZod,
-  GetEmailSettingsZod,
-  PatchEmailSettingsZod,
-  UpdateGaIdZod,
-  GetInvestorAccountTypeSettingsZod,
-  PatchInvestorAccountTypeSettingsZod,
-  GetSenderEmailZod,
-  PatchSenderEmailZod,
-  GetCurrentLandingPageZod,
-  PatchCurrentLandingPageZod,
-  GetPixelCodeZod,
-  PatchPixelCodeZod,
-  GetDemoCredentialsZod,
-  UpdateDemoPassword,
-  GetPublicDataTypesZod,
-  PatchPublicDataTypesZod,
-  GetDefaultThemeConfigZod,
-  PostDefaultThemeSetupZod,
-  DefaultEmailThemeConfigsZod,
-} 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',
-      metadata: {
-        auth: true,
-      },
-      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',
-      metadata: {
-        auth: true,
-      },
-      body: PatchPasswordProtectionSettingsZod,
-      responses: {
-        201: GetPasswordProtectionSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getInvestorAccountTypeSettings: {
-      summary: 'Get the investor account type settings for the current account',
-      method: 'GET',
-      path: '/investor-account-types',
-      metadata: {
-        auth: true,
-      },
-      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: PatchInvestorAccountTypeSettingsZod,
-      responses: {
-        201: GetInvestorAccountTypeSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getDomainSettings: {
-      summary: 'Get the domain for the current issuer',
-      method: 'GET',
-      path: '/domains',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetSiteDomainZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateDomainSettings: {
-      summary: 'Update the domain for the current issuer',
-      method: 'PATCH',
-      path: '/domains',
-      metadata: {
-        auth: true,
-      },
-      body: PatchSiteDomainZod,
-      responses: {
-        201: PatchSiteDomainResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    getSeoSettings: {
-      summary: 'Get the seo settings for the current account',
-      method: 'GET',
-      path: '/seo',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetSeoSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateSeoSettings: {
-      summary: 'Update the seo settings for the current account',
-      method: 'PATCH',
-      path: '/seo',
-      metadata: {
-        auth: true,
-      },
-      body: PatchSeoSettingsZod,
-      responses: {
-        201: GetSeoSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getBrandingSettings: {
-      summary: 'Get the branding setting for the current account',
-      method: 'GET',
-      path: '/branding',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetBrandingSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateBrandingSettings: {
-      summary: 'Update the branding settings for the current account',
-      method: 'PATCH',
-      path: '/branding',
-      metadata: {
-        auth: true,
-      },
-      body: PatchBrandingSettingsZod,
-      responses: {
-        201: GetBrandingSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getEmailSettings: {
-      summary: 'Get the email settings for the current account',
-      method: 'GET',
-      path: '/email',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetEmailSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateEmailSettings: {
-      summary: 'Update the email settings for the current account',
-      method: 'PATCH',
-      path: '/email',
-      metadata: {
-        auth: true,
-      },
-      body: PatchEmailSettingsZod,
-      responses: {
-        201: GetEmailSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getThemes: {
-      summary: 'Get the themes for the current account',
-      method: 'GET',
-      path: '/themes',
-      metadata: {
-        auth: true,
-      },
-      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,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: ITheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    postTheme: {
-      summary: 'Post a theme',
-      method: 'POST',
-      path: '/themes',
-      metadata: {
-        auth: true,
-      },
-      body: PostThemeZod,
-      responses: {
-        201: ITheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    patchThemeSettings: {
-      summary: 'Patch theme settings',
-      method: 'PATCH',
-      path: '/themes/:id/theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeIdSchema,
-      }),
-      body: PatchThemeSettings,
-      responses: {
-        201: IThemeSettings,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        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: PatchThemeSetting,
-      responses: {
-        201: IThemeSetting,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    importThemeSettings: {
-      summary: 'Import theme settings',
-      method: 'POST',
-      path: '/themes/:id/import-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: themeIdSchema,
-      }),
-      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: PatchThemeNameZod,
-      responses: {
-        201: ITheme,
-        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: UpdateGaIdZod,
-      responses: {
-        201: SiteZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getSenderEmail: {
-      summary: 'Get the sender email for the current account',
-      method: 'GET',
-      path: '/sender-email',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetSenderEmailZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchSenderEmail: {
-      summary: 'Patch the sender email for the current issuer',
-      method: 'PATCH',
-      path: '/sender-email',
-      metadata: {
-        auth: true,
-      },
-      body: PatchSenderEmailZod,
-      responses: {
-        201: GetSenderEmailZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getCurrentLandingPage: {
-      summary: 'Get the current landing page for the account',
-      method: 'GET',
-      path: '/landing-page',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetCurrentLandingPageZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchCurrentLandingPage: {
-      summary: 'Update the current landing page for the account',
-      method: 'PATCH',
-      path: '/landing-page',
-      metadata: {
-        auth: true,
-      },
-      body: PatchCurrentLandingPageZod,
-      responses: {
-        201: GetCurrentLandingPageZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPixelCode: {
-      summary: 'Get the pixel code for the current account',
-      method: 'GET',
-      path: '/pixel-code',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetPixelCodeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchPixelCode: {
-      summary: 'Update the pixel code for the current account',
-      method: 'PATCH',
-      path: '/pixel-code',
-      metadata: {
-        auth: true,
-      },
-      body: PatchPixelCodeZod,
-      responses: {
-        201: GetPixelCodeZod,
-        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,
-      },
-      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: UpdateDemoPassword,
-      responses: {
-        201: GetDemoCredentialsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPublicDataTypes: {
-      summary: 'Get the public data types for the current account',
-      method: 'GET',
-      path: '/public-data-types',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetPublicDataTypesZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchPublicDataTypes: {
-      summary: 'Update the public data types for the current account',
-      method: 'PATCH',
-      path: '/public-data-types',
-      metadata: {
-        auth: true,
-      },
-      body: PatchPublicDataTypesZod,
-      responses: {
-        201: GetPublicDataTypesZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDefaultThemeConfigs: {
-      summary: 'Get the default theme configs for the current account',
-      method: 'GET',
-      path: '/default-theme-configs',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: DefaultEmailThemeConfigsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getDefaultThemeConfig: {
-      summary: 'Get the default theme configs for the current account',
-      method: 'GET',
-      path: '/default-theme-config',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: GetDefaultThemeConfigZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    postDefaultThemeSetup: {
-      summary: 'Post the default theme setup for the current account',
-      method: 'POST',
-      path: '/default-theme-setup',
-      metadata: {
-        auth: true,
-      },
-      body: PostDefaultThemeSetupZod,
-      responses: {
-        201: GetDefaultThemeConfigZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'site-settings',
-  },
-);

package/contracts/issuers/sites/index.ts

@@ -1,32 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { SitesIncludeQuery, SiteZod } from '../../../common/types/site.types';
-
-const c = initContract();
-
-export const sitesContract = c.router(
-  {
-    getSite: {
-      summary: 'get site of the current account',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: SitesIncludeQuery,
-      responses: {
-        200: SiteZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'sites',
-  },
-);

package/contracts/issuers/tasks/index.ts

@@ -1,111 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  InternalError,
-  IPaginatedTask,
-  TaskZod,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  taskIdSchema,
-  IssuersTaskFiltersZod,
-  PatchTaskZod,
-  TasksIncludeQuery,
-  PostTaskBody,
-  BadRequestError,
-  MarkTaskAsDoneZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const issuerTasksContract = c.router(
-  {
-    postTask: {
-      summary: 'Create a task',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostTaskBody,
-      responses: {
-        201: TaskZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getTasks: {
-      summary: 'Get tasks',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(IssuersTaskFiltersZod).merge(
-        TasksIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedTask,
-        401: UnauthorizedError,
-      },
-    },
-    getTask: {
-      summary: 'Get task by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: taskIdSchema,
-      }),
-      query: TasksIncludeQuery,
-      responses: {
-        200: TaskZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-      },
-    },
-    patchTask: {
-      summary: 'Update task by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: taskIdSchema,
-      }),
-      body: PatchTaskZod,
-      responses: {
-        200: TaskZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    markTaskAsDone: {
-      summary: 'Mark task as done',
-      method: 'PATCH',
-      path: '/:id/done',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: taskIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: MarkTaskAsDoneZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'tasks',
-  },
-);