magicbell-js 0.0.2 → 0.0.4

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const enterprise = z.lazy(() => {
+  return z.object({
+    id: z.string(),
+    name: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Enterprise} enterprise
+ * @property {string}
+ * @property {string}
+ */
+export type Enterprise = z.infer<typeof enterprise>;
+
+/**
+ * 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 enterpriseResponse = z.lazy(() => {
+  return z
+    .object({
+      id: z.string(),
+      name: z.string(),
+    })
+    .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 enterpriseRequest = z.lazy(() => {
+  return z
+    .object({
+      id: z.string(),
+      name: z.string(),
+    })
+    .transform((data) => ({
+      id: data['id'],
+      name: data['name'],
+    }));
+});

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

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const footer = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+    borderRadius: z.string(),
+    fontSize: z.string(),
+    textColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Footer} footer
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type Footer = z.infer<typeof footer>;
+
+/**
+ * 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 footerResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      borderRadius: z.string(),
+      fontSize: z.string(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      borderRadius: data['borderRadius'],
+      fontSize: data['fontSize'],
+      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 footerRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      borderRadius: z.string(),
+      fontSize: z.string(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      borderRadius: data['borderRadius'],
+      fontSize: data['fontSize'],
+      textColor: data['textColor'],
+    }));
+});

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

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const header = z.lazy(() => {
+  return z.object({
+    backgroundColor: z.string(),
+    borderRadius: z.string(),
+    fontFamily: z.string(),
+    fontSize: z.string(),
+    textColor: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Header} header
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type Header = z.infer<typeof header>;
+
+/**
+ * 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 headerResponse = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      borderRadius: z.string(),
+      fontFamily: z.string(),
+      fontSize: z.string(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      borderRadius: data['borderRadius'],
+      fontFamily: data['fontFamily'],
+      fontSize: data['fontSize'],
+      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 headerRequest = z.lazy(() => {
+  return z
+    .object({
+      backgroundColor: z.string(),
+      borderRadius: z.string(),
+      fontFamily: z.string(),
+      fontSize: z.string(),
+      textColor: z.string(),
+    })
+    .transform((data) => ({
+      backgroundColor: data['backgroundColor'],
+      borderRadius: data['borderRadius'],
+      fontFamily: data['fontFamily'],
+      fontSize: data['fontSize'],
+      textColor: data['textColor'],
+    }));
+});

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const icon = z.lazy(() => {
+  return z.object({
+    borderColor: z.string(),
+    width: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Icon} icon
+ * @property {string}
+ * @property {string}
+ */
+export type Icon = z.infer<typeof icon>;
+
+/**
+ * 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 iconResponse = z.lazy(() => {
+  return z
+    .object({
+      borderColor: z.string(),
+      width: z.string(),
+    })
+    .transform((data) => ({
+      borderColor: data['borderColor'],
+      width: data['width'],
+    }));
+});
+
+/**
+ * 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 iconRequest = z.lazy(() => {
+  return z
+    .object({
+      borderColor: z.string(),
+      width: z.string(),
+    })
+    .transform((data) => ({
+      borderColor: data['borderColor'],
+      width: data['width'],
+    }));
+});

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

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const images = z.lazy(() => {
+  return z.object({
+    emptyInboxUrl: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Images} images
+ * @property {string}
+ */
+export type Images = z.infer<typeof images>;
+
+/**
+ * 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 imagesResponse = z.lazy(() => {
+  return z
+    .object({
+      emptyInboxUrl: z.string(),
+    })
+    .transform((data) => ({
+      emptyInboxUrl: data['emptyInboxUrl'],
+    }));
+});
+
+/**
+ * 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 imagesRequest = z.lazy(() => {
+  return z
+    .object({
+      emptyInboxUrl: z.string(),
+    })
+    .transform((data) => ({
+      emptyInboxUrl: data['emptyInboxUrl'],
+    }));
+});

package/src/user-client/services/integrations/models/inbox-config-payload.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+
+import { Images, images, imagesRequest, imagesResponse } from './images.js';
+import { Theme, theme, themeRequest, themeResponse } from './theme.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const inboxConfigPayload = z.lazy(() => {
+  return z.object({
+    images: images.nullable(),
+    locale: z.string().min(2).nullable(),
+    theme: theme.nullable(),
+  });
+});
+
+/**
+ *
+ * @typedef  {InboxConfigPayload} inboxConfigPayload
+ * @property {Images}
+ * @property {string}
+ * @property {Theme}
+ */
+export type InboxConfigPayload = z.infer<typeof inboxConfigPayload>;
+
+/**
+ * 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 inboxConfigPayloadResponse = z.lazy(() => {
+  return z
+    .object({
+      images: imagesResponse.nullable(),
+      locale: z.string().min(2).nullable(),
+      theme: themeResponse.nullable(),
+    })
+    .transform((data) => ({
+      images: data['images'],
+      locale: data['locale'],
+      theme: data['theme'],
+    }));
+});
+
+/**
+ * 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 inboxConfigPayloadRequest = z.lazy(() => {
+  return z
+    .object({
+      images: imagesRequest.nullable(),
+      locale: z.string().min(2).nullable(),
+      theme: themeRequest.nullable(),
+    })
+    .transform((data) => ({
+      images: data['images'],
+      locale: data['locale'],
+      theme: data['theme'],
+    }));
+});

package/src/user-client/services/integrations/models/incoming-webhook.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const incomingWebhook = z.lazy(() => {
+  return z.object({
+    channel: z.string(),
+    configurationUrl: z.string(),
+    url: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {IncomingWebhook} incomingWebhook
+ * @property {string}
+ * @property {string}
+ * @property {string}
+ */
+export type IncomingWebhook = z.infer<typeof incomingWebhook>;
+
+/**
+ * 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 incomingWebhookResponse = z.lazy(() => {
+  return z
+    .object({
+      channel: z.string(),
+      configuration_url: z.string(),
+      url: z.string(),
+    })
+    .transform((data) => ({
+      channel: data['channel'],
+      configurationUrl: data['configuration_url'],
+      url: data['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 incomingWebhookRequest = z.lazy(() => {
+  return z
+    .object({
+      channel: z.string(),
+      configurationUrl: z.string(),
+      url: z.string(),
+    })
+    .transform((data) => ({
+      channel: data['channel'],
+      configuration_url: data['configurationUrl'],
+      url: data['url'],
+    }));
+});

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

@@ -0,0 +1,29 @@
+export type { AuthedUser } from './authed-user.js';
+export type { Banner } from './banner.js';
+export type { Default_ } from './default_.js';
+export type { DefaultHover } from './default-hover.js';
+export type { DefaultState } from './default-state.js';
+export type { Dialog } from './dialog.js';
+export type { Enterprise } from './enterprise.js';
+export type { Footer } from './footer.js';
+export type { Header } from './header.js';
+export type { Icon } from './icon.js';
+export type { Images } from './images.js';
+export type { InboxConfigPayload } from './inbox-config-payload.js';
+export type { IncomingWebhook } from './incoming-webhook.js';
+export type { SlackFinishInstallResponse } from './slack-finish-install-response.js';
+export type { SlackInstallation } from './slack-installation.js';
+export type { SlackStartInstall } from './slack-start-install.js';
+export type { SlackStartInstallResponseContent } from './slack-start-install-response-content.js';
+export type { Team } from './team.js';
+export type { TemplatesInstallation } from './templates-installation.js';
+export type { Theme } from './theme.js';
+export type { ThemeNotification } from './theme-notification.js';
+export type { Unread } from './unread.js';
+export type { UnreadHover } from './unread-hover.js';
+export type { UnreadState } from './unread-state.js';
+export type { Unseen } from './unseen.js';
+export type { UnseenBadge } from './unseen-badge.js';
+export type { UnseenHover } from './unseen-hover.js';
+export type { UnseenState } from './unseen-state.js';
+export type { WebPushStartInstallationResponse } from './web-push-start-installation-response.js';

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const slackFinishInstallResponse = z.lazy(() => {
+  return z.object({
+    appId: z.string(),
+    code: z.string(),
+    redirectUrl: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {SlackFinishInstallResponse} slackFinishInstallResponse
+ * @property {string} - The app ID of the Slack app that was originally configured at the project-level.
+ * @property {string} - The code that was returned from the OAuth flow, and found in the query string of the redirect URL.
+ * @property {string}
+ */
+export type SlackFinishInstallResponse = z.infer<typeof slackFinishInstallResponse>;
+
+/**
+ * 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 slackFinishInstallResponseResponse = z.lazy(() => {
+  return z
+    .object({
+      app_id: z.string(),
+      code: z.string(),
+      redirect_url: z.string().optional(),
+    })
+    .transform((data) => ({
+      appId: data['app_id'],
+      code: data['code'],
+      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 slackFinishInstallResponseRequest = z.lazy(() => {
+  return z
+    .object({
+      appId: z.string(),
+      code: z.string(),
+      redirectUrl: z.string().optional(),
+    })
+    .transform((data) => ({
+      app_id: data['appId'],
+      code: data['code'],
+      redirect_url: data['redirectUrl'],
+    }));
+});

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

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+
+import { AuthedUser, authedUser, authedUserRequest, authedUserResponse } from './authed-user.js';
+import { Enterprise, enterprise, enterpriseRequest, enterpriseResponse } from './enterprise.js';
+import {
+  IncomingWebhook,
+  incomingWebhook,
+  incomingWebhookRequest,
+  incomingWebhookResponse,
+} from './incoming-webhook.js';
+import { Team, team, teamRequest, teamResponse } from './team.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const slackInstallation = z.lazy(() => {
+  return z.object({
+    accessToken: z.string(),
+    appId: z.string(),
+    authedUser: authedUser,
+    botUserId: z.string().optional(),
+    enterprise: enterprise.optional(),
+    expiresIn: z.number().optional(),
+    id: z
+      .string()
+      .regex(/^[A-Z0-9]+-.*$/)
+      .optional(),
+    incomingWebhook: incomingWebhook.optional(),
+    isEnterpriseInstall: z.boolean().optional(),
+    refreshToken: z.string().optional(),
+    scope: z.string().optional(),
+    team: team,
+    tokenType: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {SlackInstallation} slackInstallation
+ * @property {string}
+ * @property {string}
+ * @property {AuthedUser}
+ * @property {string}
+ * @property {Enterprise}
+ * @property {number}
+ * @property {string}
+ * @property {IncomingWebhook}
+ * @property {boolean}
+ * @property {string}
+ * @property {string}
+ * @property {Team}
+ * @property {string}
+ */
+export type SlackInstallation = z.infer<typeof slackInstallation>;
+
+/**
+ * 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 slackInstallationResponse = z.lazy(() => {
+  return z
+    .object({
+      access_token: z.string(),
+      app_id: z.string(),
+      authed_user: authedUserResponse,
+      bot_user_id: z.string().optional(),
+      enterprise: enterpriseResponse.optional(),
+      expires_in: z.number().optional(),
+      id: z
+        .string()
+        .regex(/^[A-Z0-9]+-.*$/)
+        .optional(),
+      incoming_webhook: incomingWebhookResponse.optional(),
+      is_enterprise_install: z.boolean().optional(),
+      refresh_token: z.string().optional(),
+      scope: z.string().optional(),
+      team: teamResponse,
+      token_type: z.string().optional(),
+    })
+    .transform((data) => ({
+      accessToken: data['access_token'],
+      appId: data['app_id'],
+      authedUser: data['authed_user'],
+      botUserId: data['bot_user_id'],
+      enterprise: data['enterprise'],
+      expiresIn: data['expires_in'],
+      id: data['id'],
+      incomingWebhook: data['incoming_webhook'],
+      isEnterpriseInstall: data['is_enterprise_install'],
+      refreshToken: data['refresh_token'],
+      scope: data['scope'],
+      team: data['team'],
+      tokenType: data['token_type'],
+    }));
+});
+
+/**
+ * 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 slackInstallationRequest = z.lazy(() => {
+  return z
+    .object({
+      accessToken: z.string(),
+      appId: z.string(),
+      authedUser: authedUserRequest,
+      botUserId: z.string().optional(),
+      enterprise: enterpriseRequest.optional(),
+      expiresIn: z.number().optional(),
+      id: z
+        .string()
+        .regex(/^[A-Z0-9]+-.*$/)
+        .optional(),
+      incomingWebhook: incomingWebhookRequest.optional(),
+      isEnterpriseInstall: z.boolean().optional(),
+      refreshToken: z.string().optional(),
+      scope: z.string().optional(),
+      team: teamRequest,
+      tokenType: z.string().optional(),
+    })
+    .transform((data) => ({
+      access_token: data['accessToken'],
+      app_id: data['appId'],
+      authed_user: data['authedUser'],
+      bot_user_id: data['botUserId'],
+      enterprise: data['enterprise'],
+      expires_in: data['expiresIn'],
+      id: data['id'],
+      incoming_webhook: data['incomingWebhook'],
+      is_enterprise_install: data['isEnterpriseInstall'],
+      refresh_token: data['refreshToken'],
+      scope: data['scope'],
+      team: data['team'],
+      token_type: data['tokenType'],
+    }));
+});

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const slackStartInstallResponseContent = z.lazy(() => {
+  return z.object({
+    appId: z.string().optional(),
+    authUrl: z.string().optional(),
+    scopes: z.array(z.string()).optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {SlackStartInstallResponseContent} slackStartInstallResponseContent
+ * @property {string}
+ * @property {string}
+ * @property {string[]}
+ */
+export type SlackStartInstallResponseContent = z.infer<typeof slackStartInstallResponseContent>;
+
+/**
+ * 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 slackStartInstallResponseContentResponse = z.lazy(() => {
+  return z
+    .object({
+      app_id: z.string().optional(),
+      auth_url: z.string().optional(),
+      scopes: z.array(z.string()).optional(),
+    })
+    .transform((data) => ({
+      appId: data['app_id'],
+      authUrl: data['auth_url'],
+      scopes: data['scopes'],
+    }));
+});
+
+/**
+ * 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 slackStartInstallResponseContentRequest = z.lazy(() => {
+  return z
+    .object({
+      appId: z.string().optional(),
+      authUrl: z.string().optional(),
+      scopes: z.array(z.string()).optional(),
+    })
+    .transform((data) => ({
+      app_id: data['appId'],
+      auth_url: data['authUrl'],
+      scopes: data['scopes'],
+    }));
+});