sequenzy 0.1.0

package/src/resources/subscribers/events.ts

@@ -0,0 +1,142 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Events extends APIResource {
+  /**
+   * Triggers an event for a subscriber. Creates the subscriber if they don't exist.
+   * Creates the event definition if it doesn't exist.
+   *
+   * @example
+   * ```ts
+   * const response = await client.subscribers.events.trigger({
+   *   email: 'user@example.com',
+   *   event: 'purchase.completed',
+   * });
+   * ```
+   */
+  trigger(body: EventTriggerParams, options?: RequestOptions): APIPromise<EventTriggerResponse> {
+    return this._client.post('/subscribers/events', { body, ...options });
+  }
+
+  /**
+   * Triggers multiple events for a subscriber. Creates the subscriber if they don't
+   * exist. Creates event definitions if they don't exist.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.subscribers.events.triggerMultiple({
+   *     email: 'user@example.com',
+   *     events: [{ name: 'page.viewed' }],
+   *   });
+   * ```
+   */
+  triggerMultiple(
+    body: EventTriggerMultipleParams,
+    options?: RequestOptions,
+  ): APIPromise<EventTriggerMultipleResponse> {
+    return this._client.post('/subscribers/events/bulk', { body, ...options });
+  }
+}
+
+export interface EventTriggerResponse {
+  event?: EventTriggerResponse.Event;
+
+  subscriber?: EventTriggerResponse.Subscriber;
+
+  success?: boolean;
+}
+
+export namespace EventTriggerResponse {
+  export interface Event {
+    /**
+     * The created event record ID
+     */
+    id?: string;
+
+    /**
+     * Whether the event definition was newly created
+     */
+    definitionCreated?: boolean;
+
+    name?: string;
+  }
+
+  export interface Subscriber {
+    id?: string;
+
+    created?: boolean;
+
+    email?: string;
+  }
+}
+
+export interface EventTriggerMultipleResponse {
+  events?: Array<EventTriggerMultipleResponse.Event>;
+
+  subscriber?: EventTriggerMultipleResponse.Subscriber;
+
+  success?: boolean;
+}
+
+export namespace EventTriggerMultipleResponse {
+  export interface Event {
+    id?: string;
+
+    definitionCreated?: boolean;
+
+    name?: string;
+  }
+
+  export interface Subscriber {
+    id?: string;
+
+    created?: boolean;
+
+    email?: string;
+  }
+}
+
+export interface EventTriggerParams {
+  email: string;
+
+  event: string;
+
+  /**
+   * Optional attributes to set on the subscriber if created
+   */
+  customAttributes?: { [key: string]: unknown };
+
+  /**
+   * Event properties/metadata
+   */
+  properties?: { [key: string]: unknown };
+}
+
+export interface EventTriggerMultipleParams {
+  email: string;
+
+  events: Array<EventTriggerMultipleParams.Event>;
+
+  customAttributes?: { [key: string]: unknown };
+}
+
+export namespace EventTriggerMultipleParams {
+  export interface Event {
+    name: string;
+
+    properties?: { [key: string]: unknown };
+  }
+}
+
+export declare namespace Events {
+  export {
+    type EventTriggerResponse as EventTriggerResponse,
+    type EventTriggerMultipleResponse as EventTriggerMultipleResponse,
+    type EventTriggerParams as EventTriggerParams,
+    type EventTriggerMultipleParams as EventTriggerMultipleParams,
+  };
+}

package/src/resources/subscribers/index.ts

@@ -0,0 +1,28 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Events,
+  type EventTriggerResponse,
+  type EventTriggerMultipleResponse,
+  type EventTriggerParams,
+  type EventTriggerMultipleParams,
+} from './events';
+export {
+  Subscribers,
+  type Subscriber,
+  type SubscriberCreateResponse,
+  type SubscriberRetrieveResponse,
+  type SubscriberUpdateResponse,
+  type SubscriberListResponse,
+  type SubscriberDeleteResponse,
+  type SubscriberCreateParams,
+  type SubscriberUpdateParams,
+  type SubscriberListParams,
+} from './subscribers';
+export {
+  Tags,
+  type TagAddResponse,
+  type TagAddMultipleResponse,
+  type TagAddParams,
+  type TagAddMultipleParams,
+} from './tags';

package/src/resources/subscribers/subscribers.ts

@@ -0,0 +1,238 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as EventsAPI from './events';
+import {
+  EventTriggerMultipleParams,
+  EventTriggerMultipleResponse,
+  EventTriggerParams,
+  EventTriggerResponse,
+  Events,
+} from './events';
+import * as TagsAPI from './tags';
+import { TagAddMultipleParams, TagAddMultipleResponse, TagAddParams, TagAddResponse, Tags } from './tags';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Subscribers extends APIResource {
+  tags: TagsAPI.Tags = new TagsAPI.Tags(this._client);
+  events: EventsAPI.Events = new EventsAPI.Events(this._client);
+
+  /**
+   * Creates a new subscriber. Returns 409 if subscriber already exists.
+   *
+   * @example
+   * ```ts
+   * const subscriber = await client.subscribers.create({
+   *   email: 'user@example.com',
+   * });
+   * ```
+   */
+  create(body: SubscriberCreateParams, options?: RequestOptions): APIPromise<SubscriberCreateResponse> {
+    return this._client.post('/subscribers', { body, ...options });
+  }
+
+  /**
+   * Retrieves a subscriber by their email address.
+   *
+   * @example
+   * ```ts
+   * const subscriber = await client.subscribers.retrieve(
+   *   'email',
+   * );
+   * ```
+   */
+  retrieve(email: string, options?: RequestOptions): APIPromise<SubscriberRetrieveResponse> {
+    return this._client.get(path`/subscribers/${email}`, options);
+  }
+
+  /**
+   * Updates a subscriber's first name, last name, status, tags, or custom
+   * attributes.
+   *
+   * @example
+   * ```ts
+   * const subscriber = await client.subscribers.update('email');
+   * ```
+   */
+  update(
+    email: string,
+    body: SubscriberUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<SubscriberUpdateResponse> {
+    return this._client.patch(path`/subscribers/${email}`, { body, ...options });
+  }
+
+  /**
+   * Lists subscribers with pagination and optional filtering by status or email.
+   *
+   * @example
+   * ```ts
+   * const subscribers = await client.subscribers.list();
+   * ```
+   */
+  list(
+    query: SubscriberListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<SubscriberListResponse> {
+    return this._client.get('/subscribers', { query, ...options });
+  }
+
+  /**
+   * Deletes a subscriber by their email address.
+   *
+   * @example
+   * ```ts
+   * const subscriber = await client.subscribers.delete('email');
+   * ```
+   */
+  delete(email: string, options?: RequestOptions): APIPromise<SubscriberDeleteResponse> {
+    return this._client.delete(path`/subscribers/${email}`, options);
+  }
+}
+
+export interface Subscriber {
+  id?: string;
+
+  createdAt?: string;
+
+  customAttributes?: { [key: string]: unknown };
+
+  email?: string;
+
+  firstName?: string | null;
+
+  lastName?: string | null;
+
+  status?: 'active' | 'unsubscribed';
+
+  tags?: Array<string>;
+
+  updatedAt?: string;
+}
+
+export interface SubscriberCreateResponse {
+  subscriber?: Subscriber;
+
+  success?: boolean;
+}
+
+export interface SubscriberRetrieveResponse {
+  subscriber?: Subscriber;
+
+  success?: boolean;
+}
+
+export interface SubscriberUpdateResponse {
+  subscriber?: Subscriber;
+
+  success?: boolean;
+}
+
+export interface SubscriberListResponse {
+  pagination?: SubscriberListResponse.Pagination;
+
+  subscribers?: Array<Subscriber>;
+
+  success?: boolean;
+}
+
+export namespace SubscriberListResponse {
+  export interface Pagination {
+    limit?: number;
+
+    page?: number;
+
+    total?: number;
+
+    totalPages?: number;
+  }
+}
+
+export interface SubscriberDeleteResponse {
+  deleted?: boolean;
+
+  success?: boolean;
+}
+
+export interface SubscriberCreateParams {
+  email: string;
+
+  customAttributes?: { [key: string]: unknown };
+
+  firstName?: string;
+
+  lastName?: string;
+
+  status?: 'active' | 'unsubscribed';
+
+  tags?: Array<string>;
+}
+
+export interface SubscriberUpdateParams {
+  customAttributes?: { [key: string]: unknown };
+
+  firstName?: string;
+
+  lastName?: string;
+
+  status?: 'active' | 'unsubscribed';
+
+  tags?: Array<string>;
+}
+
+export interface SubscriberListParams {
+  /**
+   * Filter by email (partial match)
+   */
+  email?: string;
+
+  /**
+   * Number of items per page (max 100)
+   */
+  limit?: number;
+
+  /**
+   * Page number
+   */
+  page?: number;
+
+  /**
+   * Filter by subscriber status
+   */
+  status?: 'active' | 'unsubscribed';
+}
+
+Subscribers.Tags = Tags;
+Subscribers.Events = Events;
+
+export declare namespace Subscribers {
+  export {
+    type Subscriber as Subscriber,
+    type SubscriberCreateResponse as SubscriberCreateResponse,
+    type SubscriberRetrieveResponse as SubscriberRetrieveResponse,
+    type SubscriberUpdateResponse as SubscriberUpdateResponse,
+    type SubscriberListResponse as SubscriberListResponse,
+    type SubscriberDeleteResponse as SubscriberDeleteResponse,
+    type SubscriberCreateParams as SubscriberCreateParams,
+    type SubscriberUpdateParams as SubscriberUpdateParams,
+    type SubscriberListParams as SubscriberListParams,
+  };
+
+  export {
+    Tags as Tags,
+    type TagAddResponse as TagAddResponse,
+    type TagAddMultipleResponse as TagAddMultipleResponse,
+    type TagAddParams as TagAddParams,
+    type TagAddMultipleParams as TagAddMultipleParams,
+  };
+
+  export {
+    Events as Events,
+    type EventTriggerResponse as EventTriggerResponse,
+    type EventTriggerMultipleResponse as EventTriggerMultipleResponse,
+    type EventTriggerParams as EventTriggerParams,
+    type EventTriggerMultipleParams as EventTriggerMultipleParams,
+  };
+}

package/src/resources/subscribers/tags.ts

@@ -0,0 +1,133 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Tags extends APIResource {
+  /**
+   * Adds a tag to a subscriber. Creates the subscriber if they don't exist. Creates
+   * the tag definition if it doesn't exist.
+   *
+   * @example
+   * ```ts
+   * const response = await client.subscribers.tags.add({
+   *   email: 'user@example.com',
+   *   tag: 'premium',
+   * });
+   * ```
+   */
+  add(body: TagAddParams, options?: RequestOptions): APIPromise<TagAddResponse> {
+    return this._client.post('/subscribers/tags', { body, ...options });
+  }
+
+  /**
+   * Adds multiple tags to a subscriber. Creates the subscriber if they don't exist.
+   * Creates tag definitions if they don't exist.
+   *
+   * @example
+   * ```ts
+   * const response = await client.subscribers.tags.addMultiple({
+   *   email: 'user@example.com',
+   *   tags: ['premium', 'newsletter', 'vip'],
+   * });
+   * ```
+   */
+  addMultiple(body: TagAddMultipleParams, options?: RequestOptions): APIPromise<TagAddMultipleResponse> {
+    return this._client.post('/subscribers/tags/bulk', { body, ...options });
+  }
+}
+
+export interface TagAddResponse {
+  subscriber?: TagAddResponse.Subscriber;
+
+  success?: boolean;
+
+  tag?: TagAddResponse.Tag;
+}
+
+export namespace TagAddResponse {
+  export interface Subscriber {
+    id?: string;
+
+    /**
+     * Whether the subscriber was newly created
+     */
+    created?: boolean;
+
+    email?: string;
+
+    tags?: Array<string>;
+  }
+
+  export interface Tag {
+    id?: string;
+
+    /**
+     * Whether the tag definition was newly created
+     */
+    created?: boolean;
+
+    name?: string;
+  }
+}
+
+export interface TagAddMultipleResponse {
+  subscriber?: TagAddMultipleResponse.Subscriber;
+
+  success?: boolean;
+
+  tags?: TagAddMultipleResponse.Tags;
+}
+
+export namespace TagAddMultipleResponse {
+  export interface Subscriber {
+    id?: string;
+
+    created?: boolean;
+
+    email?: string;
+
+    tags?: Array<string>;
+  }
+
+  export interface Tags {
+    /**
+     * Tag names that were added
+     */
+    added?: Array<string>;
+
+    /**
+     * Tag definitions that were newly created
+     */
+    created?: Array<string>;
+  }
+}
+
+export interface TagAddParams {
+  email: string;
+
+  tag: string;
+
+  /**
+   * Optional attributes to set on the subscriber if created
+   */
+  customAttributes?: { [key: string]: unknown };
+}
+
+export interface TagAddMultipleParams {
+  email: string;
+
+  tags: Array<string>;
+
+  customAttributes?: { [key: string]: unknown };
+}
+
+export declare namespace Tags {
+  export {
+    type TagAddResponse as TagAddResponse,
+    type TagAddMultipleResponse as TagAddMultipleResponse,
+    type TagAddParams as TagAddParams,
+    type TagAddMultipleParams as TagAddMultipleParams,
+  };
+}

package/src/resources/subscribers.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './subscribers/index';

package/src/resources/transactional.ts

@@ -0,0 +1,167 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import * as TransactionalAPI from './transactional';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Transactional extends APIResource {
+  /**
+   * Gets details of a transactional email template including available template
+   * variables.
+   *
+   * @example
+   * ```ts
+   * const transactional = await client.transactional.retrieve(
+   *   'welcome-email',
+   * );
+   * ```
+   */
+  retrieve(slug: string, options?: RequestOptions): APIPromise<TransactionalRetrieveResponse> {
+    return this._client.get(path`/transactional/${slug}`, options);
+  }
+
+  /**
+   * Lists all transactional email templates for your company.
+   *
+   * @example
+   * ```ts
+   * const transactionals = await client.transactional.list();
+   * ```
+   */
+  list(options?: RequestOptions): APIPromise<TransactionalListResponse> {
+    return this._client.get('/transactional', options);
+  }
+
+  /**
+   * Queues a transactional email for sending. You can either:
+   *
+   * - Provide a `slug` to use a saved template
+   * - Provide `subject` and `body` to send custom content directly
+   *
+   * Variables can be passed to customize the email content. Returns immediately with
+   * a job ID.
+   *
+   * @example
+   * ```ts
+   * const response = await client.transactional.send({
+   *   to: 'recipient@example.com',
+   *   slug: 'welcome-email',
+   *   variables: { NAME: 'John' },
+   * });
+   * ```
+   */
+  send(body: TransactionalSendParams, options?: RequestOptions): APIPromise<TransactionalSendResponse> {
+    return this._client.post('/transactional/send', { body, ...options });
+  }
+}
+
+export interface TransactionalEmail {
+  id?: string;
+
+  createdAt?: string;
+
+  enabled?: boolean;
+
+  name?: string;
+
+  slug?: string;
+
+  updatedAt?: string;
+}
+
+export interface TransactionalRetrieveResponse {
+  success?: boolean;
+
+  transactional?: TransactionalRetrieveResponse.Transactional;
+}
+
+export namespace TransactionalRetrieveResponse {
+  export interface Transactional extends TransactionalAPI.TransactionalEmail {
+    variables?: Array<string>;
+  }
+}
+
+export interface TransactionalListResponse {
+  success?: boolean;
+
+  transactional?: Array<TransactionalEmail>;
+}
+
+export type TransactionalSendResponse =
+  | TransactionalSendResponse.SlugBasedResponse
+  | TransactionalSendResponse.DirectContentResponse;
+
+export namespace TransactionalSendResponse {
+  export interface SlugBasedResponse {
+    jobId?: string;
+
+    success?: boolean;
+
+    to?: string;
+
+    transactional?: SlugBasedResponse.Transactional;
+  }
+
+  export namespace SlugBasedResponse {
+    export interface Transactional {
+      id?: string;
+
+      name?: string;
+
+      slug?: string;
+    }
+  }
+
+  export interface DirectContentResponse {
+    jobId?: string;
+
+    success?: boolean;
+
+    to?: string;
+  }
+}
+
+export interface TransactionalSendParams {
+  /**
+   * Recipient email address
+   */
+  to: string;
+
+  /**
+   * Email body HTML content (required if not using slug)
+   */
+  body?: string;
+
+  /**
+   * Preview text for the email (only used with direct content)
+   */
+  preview?: string;
+
+  /**
+   * Slug of the transactional email template to use (mutually exclusive with
+   * subject/body)
+   */
+  slug?: string;
+
+  /**
+   * Email subject (required if not using slug)
+   */
+  subject?: string;
+
+  /**
+   * Variables for template replacement (works with both modes)
+   */
+  variables?: { [key: string]: unknown };
+}
+
+export declare namespace Transactional {
+  export {
+    type TransactionalEmail as TransactionalEmail,
+    type TransactionalRetrieveResponse as TransactionalRetrieveResponse,
+    type TransactionalListResponse as TransactionalListResponse,
+    type TransactionalSendResponse as TransactionalSendResponse,
+    type TransactionalSendParams as TransactionalSendParams,
+  };
+}

package/src/resources.ts

@@ -0,0 +1 @@
+export * from './resources/index';