magicbell-js 1.3.0 → 1.4.0

package/src/project-client/services/integrations/models/smtp-config-reply-to.ts

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

package/src/project-client/services/integrations/models/smtp-config.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+
+import { SmtpConfigFrom, smtpConfigFrom, smtpConfigFromRequest, smtpConfigFromResponse } from './smtp-config-from.js';
+import {
+  SmtpConfigReplyTo,
+  smtpConfigReplyTo,
+  smtpConfigReplyToRequest,
+  smtpConfigReplyToResponse,
+} from './smtp-config-reply-to.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const smtpConfig = z.lazy(() => {
+  return z.object({
+    from: smtpConfigFrom,
+    host: z.string(),
+    password: z.string(),
+    port: z.number().gte(1).lte(65535),
+    replyTo: smtpConfigReplyTo.optional(),
+    security: z.string().optional(),
+    username: z.string(),
+  });
+});
+
+/**
+ *
+ * @typedef  {SmtpConfig} smtpConfig
+ * @property {SmtpConfigFrom} - Default sender email address
+ * @property {string} - SMTP server hostname
+ * @property {string} - SMTP authentication password
+ * @property {number} - SMTP server port
+ * @property {SmtpConfigReplyTo} - Reply-to email address
+ * @property {Security} - SMTP security/encryption method
+ * @property {string} - SMTP authentication username
+ */
+export type SmtpConfig = z.infer<typeof smtpConfig>;
+
+/**
+ * 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 smtpConfigResponse = z.lazy(() => {
+  return z
+    .object({
+      from: smtpConfigFromResponse,
+      host: z.string(),
+      password: z.string(),
+      port: z.number().gte(1).lte(65535),
+      reply_to: smtpConfigReplyToResponse.optional(),
+      security: z.string().optional(),
+      username: z.string(),
+    })
+    .transform((data) => ({
+      from: data['from'],
+      host: data['host'],
+      password: data['password'],
+      port: data['port'],
+      replyTo: data['reply_to'],
+      security: data['security'],
+      username: data['username'],
+    }));
+});
+
+/**
+ * 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 smtpConfigRequest = z.lazy(() => {
+  return z
+    .object({
+      from: smtpConfigFromRequest,
+      host: z.string(),
+      password: z.string(),
+      port: z.number().gte(1).lte(65535),
+      replyTo: smtpConfigReplyToRequest.optional(),
+      security: z.string().optional(),
+      username: z.string(),
+    })
+    .transform((data) => ({
+      from: data['from'],
+      host: data['host'],
+      password: data['password'],
+      port: data['port'],
+      reply_to: data['replyTo'],
+      security: data['security'],
+      username: data['username'],
+    }));
+});

package/src/project-client/services/integrations/models/stripe-config-payload.ts

@@ -5,6 +5,7 @@ import { z } from 'zod';
  */
 export const stripeConfigPayload = z.lazy(() => {
   return z.object({
+    id: z.string().optional(),
     webhookSigningSecret: z.string().min(1).max(100),
   });
 });
@@ -12,6 +13,7 @@ export const stripeConfigPayload = z.lazy(() => {
 /**
  *
  * @typedef  {StripeConfigPayload} stripeConfigPayload
+ * @property {string} - The unique identifier for this configuration
  * @property {string} - The signing secret to verify incoming requests from Stripe
  */
 export type StripeConfigPayload = z.infer<typeof stripeConfigPayload>;
@@ -23,9 +25,11 @@ export type StripeConfigPayload = z.infer<typeof stripeConfigPayload>;
 export const stripeConfigPayloadResponse = z.lazy(() => {
   return z
     .object({
+      id: z.string().optional(),
       webhook_signing_secret: z.string().min(1).max(100),
     })
     .transform((data) => ({
+      id: data['id'],
       webhookSigningSecret: data['webhook_signing_secret'],
     }));
 });
@@ -37,9 +41,11 @@ export const stripeConfigPayloadResponse = z.lazy(() => {
 export const stripeConfigPayloadRequest = z.lazy(() => {
   return z
     .object({
+      id: z.string().optional(),
       webhookSigningSecret: z.string().min(1).max(100),
     })
     .transform((data) => ({
+      id: data['id'],
       webhook_signing_secret: data['webhookSigningSecret'],
     }));
 });

package/src/project-client/services/integrations/models/webpush-config-payload.ts

@@ -14,7 +14,7 @@ export const webpushConfigPayload = z.lazy(() => {
  *
  * @typedef  {WebpushConfigPayload} webpushConfigPayload
  * @property {string} - VAPID private key - from the pair you generated.
- * @property {string} - VAPID public key - generate one at https://tools.reactpwa.com/vapid.
+ * @property {string} - VAPID public key - generate one at https://magicbell.com/web-push/vapid-keys.
  */
 export type WebpushConfigPayload = z.infer<typeof webpushConfigPayload>;
 

package/src/project-client/services/integrations/request-params.ts

@@ -8,6 +8,10 @@ export interface DeleteApnsIntegrationParams {
   id?: string;
 }
 
+export interface DeleteEventsourceIntegrationParams {
+  id?: string;
+}
+
 export interface DeleteExpoIntegrationParams {
   id?: string;
 }
@@ -24,6 +28,10 @@ export interface DeleteInboxIntegrationParams {
   id?: string;
 }
 
+export interface DeleteMagicbellSlackbotIntegrationParams {
+  id?: string;
+}
+
 export interface DeleteMailgunIntegrationParams {
   id?: string;
 }
@@ -44,6 +52,10 @@ export interface DeleteSlackIntegrationParams {
   id?: string;
 }
 
+export interface DeleteSmtpIntegrationParams {
+  id?: string;
+}
+
 export interface DeleteStripeIntegrationParams {
   id?: string;
 }

package/src/project-client/services/users/users-service.ts

@@ -17,8 +17,8 @@ export class UsersService extends BaseService {
    * @param {string} [params.startingAfter] -
    * @param {string} [params.endingBefore] -
    * @param {string} [params.query] -
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<UserCollection>>} OK
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<UserCollection>>} - OK
    */
   async listUsers(params?: ListUsersParams, requestConfig?: RequestConfig): Promise<HttpResponse<UserCollection>> {
     const request = new RequestBuilder()
@@ -59,8 +59,8 @@ export class UsersService extends BaseService {
 
   /**
    * Creates or updates a user with the provided details. The user will be associated with the project specified in the request context.
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<User>>} OK
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<User>>} - OK
    */
   async saveUser(body: User, requestConfig?: RequestConfig): Promise<HttpResponse<User>> {
     const request = new RequestBuilder()
@@ -88,8 +88,8 @@ export class UsersService extends BaseService {
   /**
    * Removes a user and all associated data from the project.
    * @param {string} userId -
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<any>>} No Content
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<any>>} - No Content
    */
   async deleteUser(userId: string, requestConfig?: RequestConfig): Promise<HttpResponse<void>> {
     const request = new RequestBuilder()

package/src/project-client/services/workflows/index.ts

@@ -0,0 +1,2 @@
+export * from './models/index.js';
+export { WorkflowsService } from './workflows-service.js';

package/src/project-client/services/workflows/models/create-run-response.ts

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

package/src/project-client/services/workflows/models/execute-workflow-request.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const executeWorkflowRequest = z.lazy(() => {
+  return z.object({
+    input: z.any().optional().nullable(),
+    key: z.string().regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+  });
+});
+
+/**
+ *
+ * @typedef  {ExecuteWorkflowRequest} executeWorkflowRequest
+ * @property {any}
+ * @property {string}
+ */
+export type ExecuteWorkflowRequest = z.infer<typeof executeWorkflowRequest>;
+
+/**
+ * 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 executeWorkflowRequestResponse = z.lazy(() => {
+  return z
+    .object({
+      input: z.any().optional().nullable(),
+      key: z.string().regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+    })
+    .transform((data) => ({
+      input: data['input'],
+      key: data['key'],
+    }));
+});
+
+/**
+ * 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 executeWorkflowRequestRequest = z.lazy(() => {
+  return z
+    .object({
+      input: z.any().optional().nullable(),
+      key: z.string().regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+    })
+    .transform((data) => ({
+      input: data['input'],
+      key: data['key'],
+    }));
+});

package/src/project-client/services/workflows/models/get-run-response-status.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const getRunResponseStatus = z.lazy(() => {
+  return z.object({
+    completedAt: z.string().optional(),
+    error: z.string().optional(),
+    nextStep: z.number().optional(),
+    startedAt: z.string().optional(),
+    state: z.number().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {GetRunResponseStatus} getRunResponseStatus
+ * @property {string}
+ * @property {string}
+ * @property {number}
+ * @property {string}
+ * @property {number}
+ */
+export type GetRunResponseStatus = z.infer<typeof getRunResponseStatus>;
+
+/**
+ * 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 getRunResponseStatusResponse = z.lazy(() => {
+  return z
+    .object({
+      completed_at: z.string().optional(),
+      error: z.string().optional(),
+      next_step: z.number().optional(),
+      started_at: z.string().optional(),
+      state: z.number().optional(),
+    })
+    .transform((data) => ({
+      completedAt: data['completed_at'],
+      error: data['error'],
+      nextStep: data['next_step'],
+      startedAt: data['started_at'],
+      state: data['state'],
+    }));
+});
+
+/**
+ * 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 getRunResponseStatusRequest = z.lazy(() => {
+  return z
+    .object({
+      completedAt: z.string().optional(),
+      error: z.string().optional(),
+      nextStep: z.number().optional(),
+      startedAt: z.string().optional(),
+      state: z.number().optional(),
+    })
+    .transform((data) => ({
+      completed_at: data['completedAt'],
+      error: data['error'],
+      next_step: data['nextStep'],
+      started_at: data['startedAt'],
+      state: data['state'],
+    }));
+});

package/src/project-client/services/workflows/models/get-run-response.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+import {
+  GetRunResponseStatus,
+  getRunResponseStatus,
+  getRunResponseStatusRequest,
+  getRunResponseStatusResponse,
+} from './get-run-response-status.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const getRunResponse = z.lazy(() => {
+  return z.object({
+    createdAt: z.string().optional(),
+    id: z.string().optional(),
+    status: getRunResponseStatus.optional(),
+    workflowKey: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {GetRunResponse} getRunResponse
+ * @property {string}
+ * @property {string}
+ * @property {GetRunResponseStatus}
+ * @property {string}
+ */
+export type GetRunResponse = z.infer<typeof getRunResponse>;
+
+/**
+ * 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 getRunResponseResponse = z.lazy(() => {
+  return z
+    .object({
+      created_at: z.string().optional(),
+      id: z.string().optional(),
+      status: getRunResponseStatusResponse.optional(),
+      workflow_key: z.string().optional(),
+    })
+    .transform((data) => ({
+      createdAt: data['created_at'],
+      id: data['id'],
+      status: data['status'],
+      workflowKey: data['workflow_key'],
+    }));
+});
+
+/**
+ * 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 getRunResponseRequest = z.lazy(() => {
+  return z
+    .object({
+      createdAt: z.string().optional(),
+      id: z.string().optional(),
+      status: getRunResponseStatusRequest.optional(),
+      workflowKey: z.string().optional(),
+    })
+    .transform((data) => ({
+      created_at: data['createdAt'],
+      id: data['id'],
+      status: data['status'],
+      workflow_key: data['workflowKey'],
+    }));
+});

package/src/project-client/services/workflows/models/index.ts

@@ -0,0 +1,9 @@
+export type { CreateRunResponse } from './create-run-response.js';
+export type { ExecuteWorkflowRequest } from './execute-workflow-request.js';
+export type { GetRunResponse } from './get-run-response.js';
+export type { GetRunResponseStatus } from './get-run-response-status.js';
+export type { Steps } from './steps.js';
+export type { WorkflowDefinition } from './workflow-definition.js';
+export type { WorkflowRun } from './workflow-run.js';
+export type { WorkflowRunCollection } from './workflow-run-collection.js';
+export type { WorkflowRunStatus } from './workflow-run-status.js';

package/src/project-client/services/workflows/models/steps.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const steps = z.lazy(() => {
+  return z.object({
+    command: z.string().regex(/^[A-Za-z0-9\_\:]+$/),
+    if: z.string().optional().nullable(),
+    input: z.any().optional().nullable(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Steps} steps
+ * @property {string}
+ * @property {string}
+ * @property {any}
+ */
+export type Steps = z.infer<typeof steps>;
+
+/**
+ * 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 stepsResponse = z.lazy(() => {
+  return z
+    .object({
+      command: z.string().regex(/^[A-Za-z0-9\_\:]+$/),
+      if: z.string().optional().nullable(),
+      input: z.any().optional().nullable(),
+    })
+    .transform((data) => ({
+      command: data['command'],
+      if: data['if'],
+      input: data['input'],
+    }));
+});
+
+/**
+ * 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 stepsRequest = z.lazy(() => {
+  return z
+    .object({
+      command: z.string().regex(/^[A-Za-z0-9\_\:]+$/),
+      if: z.string().optional().nullable(),
+      input: z.any().optional().nullable(),
+    })
+    .transform((data) => ({
+      command: data['command'],
+      if: data['if'],
+      input: data['input'],
+    }));
+});

package/src/project-client/services/workflows/models/workflow-definition.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+
+import { Steps, steps, stepsRequest, stepsResponse } from './steps.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const workflowDefinition = z.lazy(() => {
+  return z.object({
+    disabled: z.boolean().optional(),
+    key: z
+      .string()
+      .min(3)
+      .regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+    steps: z.array(steps),
+  });
+});
+
+/**
+ *
+ * @typedef  {WorkflowDefinition} workflowDefinition
+ * @property {boolean}
+ * @property {string}
+ * @property {Steps[]}
+ */
+export type WorkflowDefinition = z.infer<typeof workflowDefinition>;
+
+/**
+ * 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 workflowDefinitionResponse = z.lazy(() => {
+  return z
+    .object({
+      disabled: z.boolean().optional(),
+      key: z
+        .string()
+        .min(3)
+        .regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+      steps: z.array(stepsResponse),
+    })
+    .transform((data) => ({
+      disabled: data['disabled'],
+      key: data['key'],
+      steps: data['steps'],
+    }));
+});
+
+/**
+ * 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 workflowDefinitionRequest = z.lazy(() => {
+  return z
+    .object({
+      disabled: z.boolean().optional(),
+      key: z
+        .string()
+        .min(3)
+        .regex(/^[A-Za-z0-9\_\.\-\:]+$/),
+      steps: z.array(stepsRequest),
+    })
+    .transform((data) => ({
+      disabled: data['disabled'],
+      key: data['key'],
+      steps: data['steps'],
+    }));
+});

package/src/project-client/services/workflows/models/workflow-run-collection.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+import { Links, links, linksRequest, linksResponse } from '../../common/links.js';
+import { WorkflowRun, workflowRun, workflowRunRequest, workflowRunResponse } from './workflow-run.js';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const workflowRunCollection = z.lazy(() => {
+  return z.object({
+    data: z.array(workflowRun).optional(),
+    links: links.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {WorkflowRunCollection} workflowRunCollection
+ * @property {WorkflowRun[]}
+ * @property {Links}
+ */
+export type WorkflowRunCollection = z.infer<typeof workflowRunCollection>;
+
+/**
+ * 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 workflowRunCollectionResponse = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(workflowRunResponse).optional(),
+      links: linksResponse.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});
+
+/**
+ * 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 workflowRunCollectionRequest = z.lazy(() => {
+  return z
+    .object({
+      data: z.array(workflowRunRequest).optional(),
+      links: linksRequest.optional(),
+    })
+    .transform((data) => ({
+      data: data['data'],
+      links: data['links'],
+    }));
+});