magicbell-js 0.0.3 → 0.1.0

package/src/user-client/services/integrations/models/slack-start-install.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const slackStartInstall = z.lazy(() => {
+  return z.object({
+    appId: z.string(),
+    authUrl: z.string().optional(),
+    extraScopes: z.array(z.string()).optional(),
+    redirectUrl: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {SlackStartInstall} slackStartInstall
+ * @property {string}
+ * @property {string}
+ * @property {string[]}
+ * @property {string}
+ */
+export type SlackStartInstall = z.infer<typeof slackStartInstall>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const slackStartInstallResponse = z.lazy(() => {
+  return z
+    .object({
+      app_id: z.string(),
+      auth_url: z.string().optional(),
+      extra_scopes: z.array(z.string()).optional(),
+      redirect_url: z.string().optional(),
+    })
+    .transform((data) => ({
+      appId: data['app_id'],
+      authUrl: data['auth_url'],
+      extraScopes: data['extra_scopes'],
+      redirectUrl: data['redirect_url'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const slackStartInstallRequest = z.lazy(() => {
+  return z
+    .object({
+      appId: z.string(),
+      authUrl: z.string().optional(),
+      extraScopes: z.array(z.string()).optional(),
+      redirectUrl: z.string().optional(),
+    })
+    .transform((data) => ({
+      app_id: data['appId'],
+      auth_url: data['authUrl'],
+      extra_scopes: data['extraScopes'],
+      redirect_url: data['redirectUrl'],
+    }));
+});

package/src/user-client/services/integrations/models/team.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const team = z.lazy(() => {
+  return z.object({
+    id: z.string(),
+    name: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Team} team
+ * @property {string}
+ * @property {string}
+ */
+export type Team = z.infer<typeof team>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const teamResponse = z.lazy(() => {
+  return z
+    .object({
+      id: z.string(),
+      name: z.string().optional(),
+    })
+    .transform((data) => ({
+      id: data['id'],
+      name: data['name'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const teamRequest = z.lazy(() => {
+  return z
+    .object({
+      id: z.string(),
+      name: z.string().optional(),
+    })
+    .transform((data) => ({
+      id: data['id'],
+      name: data['name'],
+    }));
+});

package/src/user-client/services/integrations/models/templates-installation.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const templatesInstallation = z.lazy(() => {
+  return z.object({
+    category: z.string().optional().nullable(),
+    channel: z.string(),
+    text: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {TemplatesInstallation} templatesInstallation
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type TemplatesInstallation = z.infer<typeof templatesInstallation>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const templatesInstallationResponse = z.lazy(() => {
+  return z
+    .object({
+      category: z.string().optional().nullable(),
+      channel: z.string(),
+      text: z.string(),
+    })
+    .transform((data) => ({
+      category: data['category'],
+      channel: data['channel'],
+      text: data['text'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const templatesInstallationRequest = z.lazy(() => {
+  return z
+    .object({
+      category: z.string().optional().nullable(),
+      channel: z.string(),
+      text: z.string(),
+    })
+    .transform((data) => ({
+      category: data['category'],
+      channel: data['channel'],
+      text: data['text'],
+    }));
+});

package/src/user-client/services/integrations/models/theme-notification.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+
+import { Default_, default_, defaultRequest, defaultResponse } from './default_.js';
+import { Unread, unread, unreadRequest, unreadResponse } from './unread.js';
+import { Unseen, unseen, unseenRequest, unseenResponse } from './unseen.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const themeNotification = z.lazy(() => {
+  return z.object({
+    default: default_,
+    unread: unread,
+    unseen: unseen,
+  });
+});
+
+/**
+ *
+ * @typedef  {ThemeNotification} themeNotification
+ * @property {Default_}
+ * @property {Unread}
+ * @property {Unseen}
+ */
+export type ThemeNotification = z.infer<typeof themeNotification>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const themeNotificationResponse = z.lazy(() => {
+  return z
+    .object({
+      default: defaultResponse,
+      unread: unreadResponse,
+      unseen: unseenResponse,
+    })
+    .transform((data) => ({
+      default: data['default'],
+      unread: data['unread'],
+      unseen: data['unseen'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const themeNotificationRequest = z.lazy(() => {
+  return z
+    .object({
+      default: defaultRequest,
+      unread: unreadRequest,
+      unseen: unseenRequest,
+    })
+    .transform((data) => ({
+      default: data['default'],
+      unread: data['unread'],
+      unseen: data['unseen'],
+    }));
+});

package/src/user-client/services/integrations/models/theme.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+
+import { Banner, banner, bannerRequest, bannerResponse } from './banner.js';
+import { Dialog, dialog, dialogRequest, dialogResponse } from './dialog.js';
+import { Footer, footer, footerRequest, footerResponse } from './footer.js';
+import { Header, header, headerRequest, headerResponse } from './header.js';
+import { Icon, icon, iconRequest, iconResponse } from './icon.js';
+import {
+  ThemeNotification,
+  themeNotification,
+  themeNotificationRequest,
+  themeNotificationResponse,
+} from './theme-notification.js';
+import { UnseenBadge, unseenBadge, unseenBadgeRequest, unseenBadgeResponse } from './unseen-badge.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const theme = z.lazy(() => {
+  return z.object({
+    banner: banner.optional(),
+    dialog: dialog.optional(),
+    footer: footer.optional(),
+    header: header.optional(),
+    icon: icon.optional(),
+    notification: themeNotification.optional(),
+    unseenBadge: unseenBadge.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Theme} theme
+ * @property {Banner}
+ * @property {Dialog}
+ * @property {Footer}
+ * @property {Header}
+ * @property {Icon}
+ * @property {ThemeNotification}
+ * @property {UnseenBadge}
+ */
+export type Theme = z.infer<typeof theme>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const themeResponse = z.lazy(() => {
+  return z
+    .object({
+      banner: bannerResponse.optional(),
+      dialog: dialogResponse.optional(),
+      footer: footerResponse.optional(),
+      header: headerResponse.optional(),
+      icon: iconResponse.optional(),
+      notification: themeNotificationResponse.optional(),
+      unseenBadge: unseenBadgeResponse.optional(),
+    })
+    .transform((data) => ({
+      banner: data['banner'],
+      dialog: data['dialog'],
+      footer: data['footer'],
+      header: data['header'],
+      icon: data['icon'],
+      notification: data['notification'],
+      unseenBadge: data['unseenBadge'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const themeRequest = z.lazy(() => {
+  return z
+    .object({
+      banner: bannerRequest.optional(),
+      dialog: dialogRequest.optional(),
+      footer: footerRequest.optional(),
+      header: headerRequest.optional(),
+      icon: iconRequest.optional(),
+      notification: themeNotificationRequest.optional(),
+      unseenBadge: unseenBadgeRequest.optional(),
+    })
+    .transform((data) => ({
+      banner: data['banner'],
+      dialog: data['dialog'],
+      footer: data['footer'],
+      header: data['header'],
+      icon: data['icon'],
+      notification: data['notification'],
+      unseenBadge: data['unseenBadge'],
+    }));
+});

package/src/user-client/services/integrations/models/unread-hover.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unreadHover = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UnreadHover} unreadHover
+ * @property {string}
+ */
+export type UnreadHover = z.infer<typeof unreadHover>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unreadHoverResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unreadHoverRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});

package/src/user-client/services/integrations/models/unread-state.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unreadState = z.lazy(() => {
+  return z.object({
+    color: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UnreadState} unreadState
+ * @property {string}
+ */
+export type UnreadState = z.infer<typeof unreadState>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unreadStateResponse = z.lazy(() => {
+  return z
+    .object({
+      color: z.string(),
+    })
+    .transform((data) => ({
+      color: data['color'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unreadStateRequest = z.lazy(() => {
+  return z
+    .object({
+      color: z.string(),
+    })
+    .transform((data) => ({
+      color: data['color'],
+    }));
+});

package/src/user-client/services/integrations/models/unread.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+
+import { UnreadHover, unreadHover, unreadHoverRequest, unreadHoverResponse } from './unread-hover.js';
+import { UnreadState, unreadState, unreadStateRequest, unreadStateResponse } from './unread-state.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unread = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+    hover: unreadHover.optional(),
+    state: unreadState.optional(),
+    textColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Unread} unread
+ * @property {string}
+ * @property {UnreadHover}
+ * @property {UnreadState}
+ * @property {string}
+ */
+export type Unread = z.infer<typeof unread>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unreadResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      hover: unreadHoverResponse.optional(),
+      state: unreadStateResponse.optional(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      hover: data['hover'],
+      state: data['state'],
+      textColor: data['textColor'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unreadRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      hover: unreadHoverRequest.optional(),
+      state: unreadStateRequest.optional(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      hover: data['hover'],
+      state: data['state'],
+      textColor: data['textColor'],
+    }));
+});

package/src/user-client/services/integrations/models/unseen-badge.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unseenBadge = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UnseenBadge} unseenBadge
+ * @property {string}
+ */
+export type UnseenBadge = z.infer<typeof unseenBadge>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenBadgeResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenBadgeRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});

package/src/user-client/services/integrations/models/unseen-hover.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unseenHover = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UnseenHover} unseenHover
+ * @property {string}
+ */
+export type UnseenHover = z.infer<typeof unseenHover>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenHoverResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenHoverRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+    }));
+});

package/src/user-client/services/integrations/models/unseen-state.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unseenState = z.lazy(() => {
+  return z.object({
+    color: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {UnseenState} unseenState
+ * @property {string}
+ */
+export type UnseenState = z.infer<typeof unseenState>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenStateResponse = z.lazy(() => {
+  return z
+    .object({
+      color: z.string(),
+    })
+    .transform((data) => ({
+      color: data['color'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenStateRequest = z.lazy(() => {
+  return z
+    .object({
+      color: z.string(),
+    })
+    .transform((data) => ({
+      color: data['color'],
+    }));
+});

package/src/user-client/services/integrations/models/unseen.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+
+import { UnseenHover, unseenHover, unseenHoverRequest, unseenHoverResponse } from './unseen-hover.js';
+import { UnseenState, unseenState, unseenStateRequest, unseenStateResponse } from './unseen-state.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const unseen = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+    hover: unseenHover.optional(),
+    state: unseenState.optional(),
+    textColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Unseen} unseen
+ * @property {string}
+ * @property {UnseenHover}
+ * @property {UnseenState}
+ * @property {string}
+ */
+export type Unseen = z.infer<typeof unseen>;
+
+/**
+ * The shape of the model mapping from the api schema into the application shape.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      hover: unseenHoverResponse.optional(),
+      state: unseenStateResponse.optional(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      hover: data['hover'],
+      state: data['state'],
+      textColor: data['textColor'],
+    }));
+});
+
+/**
+ * The shape of the model mapping from the application shape into the api schema.
+ * Is equal to application shape if all property names match the api schema
+ */
+export const unseenRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      hover: unseenHoverRequest.optional(),
+      state: unseenStateRequest.optional(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      hover: data['hover'],
+      state: data['state'],
+      textColor: data['textColor'],
+    }));
+});