@gpt-platform/client 0.10.5 → 0.11.0

package/dist/namespaces/campaigns.d.ts

@@ -0,0 +1,973 @@
+import type { EmailMarketingTemplate, Campaign, EmailMarketingGeneratedEmail, EmailMarketingSequence, EmailMarketingSenderProfile } from "../_internal/types.gen";
+import type { MjmlCompileResult, TemplateVersion } from "./email";
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+/** @public Result of an AI-powered campaign performance analysis. */
+export type CampaignAnalysisResult = Record<string, unknown>;
+/** Attributes accepted when creating a campaign. */
+export type CreateCampaignAttributes = {
+    workspace_id: string;
+    name: string;
+    template_id: string;
+    description?: string;
+    include_unsubscribe_link?: boolean;
+    unsubscribe_message?: string;
+    include_tracking_pixel?: boolean;
+    sender_profile_id?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a campaign (PATCH semantics). */
+export type UpdateCampaignAttributes = {
+    name?: string;
+    scheduled_at?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a follow-up campaign. */
+export type CreateFollowupCampaignAttributes = {
+    name?: string;
+    subject?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a generated email (PATCH semantics). */
+export type UpdateGeneratedEmailAttributes = {
+    subject?: string;
+    body?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a sender profile (PATCH semantics). */
+export type UpdateSenderProfileAttributes = {
+    name?: string;
+    from_email?: string;
+    reply_to?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when importing recipients from a CSV file. */
+export type ImportRecipientsAttributes = {
+    csv_storage_key: string;
+    column_mapping?: Record<string, string>;
+    workspace_id: string;
+};
+/** Attributes accepted when exporting campaign data. */
+export type ExportCampaignAttributes = {
+    workspace_id: string;
+    format?: string;
+    export_type?: string;
+};
+/** Attributes accepted when optimizing subject lines with AI. */
+export type OptimizeSubjectsAttributes = {
+    original_subject: string;
+    campaign_description: string;
+    audience_description: string;
+};
+/** Attributes accepted when creating a marketing sequence. */
+export type CreateSequenceAttributes = {
+    workspace_id: string;
+    name: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a marketing sequence. */
+export type UpdateSequenceAttributes = {
+    name?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a sequence step. */
+export type CreateSequenceStepAttributes = {
+    sequence_id: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a sequence step. */
+export type UpdateSequenceStepAttributes = {
+    [key: string]: unknown;
+};
+/**
+ * Email Marketing namespace for campaigns, templates, and AI-powered email generation.
+ *
+ * Provides sub-namespaces covering the full email marketing lifecycle:
+ * campaigns (one-off or scheduled sends), templates (reusable HTML/text
+ * layouts), generated emails (AI-personalised drafts awaiting human review),
+ * sender profiles (from-address identities with DNS validation), and
+ * sequences (multi-step drip automation).
+ *
+ * @example
+ * ```typescript
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ *
+ * // Create a campaign, use AI to pick the best send time, then send
+ * const campaign = await client.campaigns.campaigns.create({
+ *   workspace_id: 'ws_abc123',
+ *   name: 'Spring Sale 2026',
+ *   subject: 'Up to 40% off this weekend only',
+ *   template_id: 'tmpl_spring',
+ * });
+ *
+ * await client.campaigns.campaigns.optimizeSendTimes(campaign.id);
+ * await client.campaigns.campaigns.send(campaign.id);
+ * ```
+ */
+export declare function createCampaignsNamespace(rb: RequestBuilder): {
+    /**
+     * Campaigns — email campaign orchestration.
+     *
+     * A campaign represents a single bulk email send (or a scheduled future
+     * send) targeting a list of recipients. Campaigns can be created from
+     * templates, analysed with AI for performance insights, have their send
+     * times AI-optimised, and spawn follow-up campaigns automatically.
+     */
+    campaigns: {
+        /**
+         * Fetch a single campaign by its unique ID.
+         *
+         * @param id - The unique identifier of the campaign to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link Campaign}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const campaign = await client.campaigns.campaigns.get('camp_abc123');
+         * console.log(campaign.attributes.name, campaign.attributes.status);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<Campaign>;
+        /**
+         * Create a new email campaign.
+         *
+         * The campaign starts in `draft` status. Populate all required fields
+         * (subject, recipients, template or body content) before calling
+         * {@link send} to trigger delivery.
+         *
+         * @param attributes - Key/value map of campaign attributes. Must include
+         *   `workspace_id` and `name`. Common fields: `subject`, `template_id`,
+         *   `sender_profile_id`, `recipient_list_id`, `scheduled_at`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created {@link Campaign}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const campaign = await client.campaigns.campaigns.create({
+         *   workspace_id: 'ws_abc123',
+         *   name: 'Q2 Product Update',
+         *   subject: 'What\'s new in Q2 2026',
+         *   template_id: 'tmpl_product_update',
+         *   sender_profile_id: 'sp_noreply',
+         * });
+         * console.log(campaign.id); // 'camp_...'
+         * ```
+         */
+        create: (attributes: CreateCampaignAttributes, options?: RequestOptions) => Promise<Campaign>;
+        /**
+         * Update an existing campaign's attributes.
+         *
+         * Only the fields present in `attributes` are changed (PATCH semantics).
+         * Campaigns can only be updated while in `draft` status.
+         *
+         * @param id - The unique identifier of the campaign to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link Campaign}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const campaign = await client.campaigns.campaigns.update('camp_abc123', {
+         *   subject: 'Revised subject line for A/B test',
+         *   scheduled_at: '2026-04-01T09:00:00Z',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateCampaignAttributes, options?: RequestOptions) => Promise<Campaign>;
+        /**
+         * Permanently delete a campaign.
+         *
+         * Only `draft` campaigns can be deleted. Campaigns that have been sent
+         * or are currently sending cannot be removed.
+         *
+         * @param id - The unique identifier of the campaign to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.campaigns.campaigns.delete('camp_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List campaigns for a workspace with optional pagination.
+         *
+         * @param workspaceId - The ID of the workspace whose campaigns to list.
+         * @param options - Optional pagination controls (`page`, `pageSize`) and
+         *   request-level overrides.
+         * @returns A promise that resolves to an array of {@link Campaign} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const campaigns = await client.campaigns.campaigns.listByWorkspace('ws_abc123', {
+         *   pageSize: 25,
+         * });
+         * const drafts = campaigns.filter((c) => c.attributes.status === 'draft');
+         * console.log(`${drafts.length} drafts awaiting send`);
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Campaign[]>;
+        /**
+         * Trigger immediate delivery of a campaign to all recipients.
+         *
+         * The campaign must be in `draft` or `scheduled` status. Once sent, the
+         * campaign transitions to `sending` and then `sent`. This action is
+         * irreversible — use with care in production.
+         *
+         * @param id - The unique identifier of the campaign to send.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves with the server's acknowledgement payload.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.campaigns.campaigns.send('camp_abc123');
+         * console.log('Campaign queued for delivery');
+         * ```
+         */
+        send: (id: string, options?: RequestOptions) => Promise<Campaign>;
+        /**
+         * Request an AI-powered performance analysis of a sent campaign.
+         *
+         * The platform's AI reviews open rates, click-through rates, unsubscribes,
+         * and engagement patterns to produce a natural-language report with
+         * actionable recommendations. Requires the campaign to be in `sent` status.
+         *
+         * @param id - The unique identifier of the campaign to analyse.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the AI-generated analysis report payload.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const report = await client.campaigns.campaigns.analyze('camp_abc123');
+         * console.log(report); // AI narrative with metrics breakdown
+         * ```
+         */
+        analyze: (id: string, options?: RequestOptions) => Promise<CampaignAnalysisResult>;
+        /**
+         * Use AI to determine the optimal send time for a campaign.
+         *
+         * Analyses recipient engagement history and timezone distribution to
+         * recommend (and optionally auto-set) a `scheduled_at` timestamp that
+         * maximises open rates. Call this before {@link send} to improve
+         * deliverability outcomes.
+         *
+         * @param id - The unique identifier of the campaign to optimise.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the optimisation result payload,
+         *   which includes the recommended send time.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const result = await client.campaigns.campaigns.optimizeSendTimes('camp_abc123');
+         * // result contains recommended_send_at and supporting rationale
+         * console.log(result);
+         * ```
+         */
+        optimizeSendTimes: (id: string, options?: RequestOptions) => Promise<Campaign>;
+        /**
+         * Create a follow-up campaign targeted at recipients who did not engage
+         * with the original campaign.
+         *
+         * The AI automatically segments non-openers / non-clickers from the
+         * parent campaign and creates a new draft campaign with a refined subject
+         * line and message. You can then review and send the follow-up via
+         * {@link send}.
+         *
+         * @param id - The ID of the original campaign to follow up on.
+         * @param attributes - Additional attributes for the follow-up campaign,
+         *   such as a custom `subject` or `scheduled_at` override.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created follow-up campaign payload.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * // Create a follow-up 3 days after the original send
+         * const followUp = await client.campaigns.campaigns.createFollowup(
+         *   'camp_abc123',
+         *   {
+         *     subject: 'Did you miss our Spring Sale?',
+         *     scheduled_at: '2026-04-04T09:00:00Z',
+         *   },
+         * );
+         * console.log('Follow-up campaign:', followUp);
+         * ```
+         */
+        createFollowup: (id: string, attributes: CreateFollowupCampaignAttributes, options?: RequestOptions) => Promise<Campaign>;
+        /**
+         * Import recipients from a CSV file stored in platform storage.
+         *
+         * @param id - The campaign ID to import recipients into.
+         * @param attributes - Import configuration including `csv_storage_key`,
+         *   optional `column_mapping`, and `workspace_id`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the import job details.
+         *
+         * @example
+         * ```typescript
+         * const result = await client.campaigns.campaigns.importRecipients('camp_abc', {
+         *   csv_storage_key: 'uploads/recipients.csv',
+         *   workspace_id: 'ws_abc123',
+         * });
+         * console.log(result.job_id);
+         * ```
+         */
+        importRecipients: (id: string, attributes: ImportRecipientsAttributes, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /**
+         * Trigger AI-powered email generation for all campaign recipients.
+         *
+         * @param id - The campaign ID to generate emails for.
+         * @param workspaceId - The workspace ID.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the generation job details.
+         *
+         * @example
+         * ```typescript
+         * const result = await client.campaigns.campaigns.generateEmails('camp_abc', 'ws_abc123');
+         * console.log(result.job_id);
+         * ```
+         */
+        generateEmails: (id: string, workspaceId: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /**
+         * Generate A/B test subject line variants using AI.
+         *
+         * @param id - The campaign ID to optimize subjects for.
+         * @param attributes - Subject optimization parameters including
+         *   `original_subject`, `campaign_description`, and `audience_description`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the optimization result with variant suggestions.
+         *
+         * @example
+         * ```typescript
+         * const result = await client.campaigns.campaigns.optimizeSubjects('camp_abc', {
+         *   original_subject: 'Spring Sale!',
+         *   campaign_description: 'Seasonal discount promotion',
+         *   audience_description: 'Existing customers aged 25-45',
+         * });
+         * ```
+         */
+        optimizeSubjects: (id: string, attributes: OptimizeSubjectsAttributes, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /**
+         * Export campaign data (recipients, results, or analytics) as CSV.
+         *
+         * @param id - The campaign ID to export.
+         * @param attributes - Export configuration including `workspace_id`,
+         *   optional `format` and `export_type`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the export job details.
+         *
+         * @example
+         * ```typescript
+         * const result = await client.campaigns.campaigns.export('camp_abc', {
+         *   workspace_id: 'ws_abc123',
+         *   export_type: 'recipients',
+         * });
+         * console.log(result.job_id);
+         * ```
+         */
+        export: (id: string, attributes: ExportCampaignAttributes, options?: RequestOptions) => Promise<Record<string, unknown>>;
+    };
+    /**
+     * Templates — reusable MJML-based email layout templates with versioning.
+     *
+     * Templates define the HTML and/or plain-text structure of an email,
+     * including header, footer, styling, and placeholder merge tags. Campaigns
+     * reference a template to avoid duplicating layout code across sends.
+     * Templates support live MJML compilation, publish/unpublish lifecycle,
+     * and immutable version snapshots for campaign reproducibility.
+     * Templates are scoped to a workspace.
+     */
+    templates: {
+        /**
+         * List all email templates for a workspace.
+         *
+         * @param workspaceId - The ID of the workspace whose templates to list.
+         * @param options - Optional pagination controls (`page`, `pageSize`) and
+         *   request-level overrides.
+         * @returns A promise that resolves to an array of {@link EmailMarketingTemplate} records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const templates = await client.campaigns.templates.listByWorkspace('ws_abc123');
+         * console.log(templates.map((t) => t.attributes.name));
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<EmailMarketingTemplate[]>;
+        /**
+         * Stateless MJML compilation. Does not save. Use for live preview in builder UI.
+         *
+         * @param mjml - Raw MJML source string to compile.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the compilation result including HTML, variables, and errors.
+         *
+         * @example
+         * ```typescript
+         * const result = await client.campaigns.templates.compile("<mjml>...</mjml>");
+         * console.log(result.html, result.variables);
+         * ```
+         */
+        compile: (mjml: string, options?: RequestOptions) => Promise<MjmlCompileResult>;
+        /**
+         * Render a saved template with variable overrides. Returns final HTML for preview.
+         *
+         * @param templateId - The ID of the template to preview.
+         * @param variables - Key/value map of variable substitutions for the preview render.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to an object containing the rendered `preview_html`.
+         *
+         * @example
+         * ```typescript
+         * const { preview_html } = await client.campaigns.templates.preview("tmpl_123", { first_name: "Jane" });
+         * ```
+         */
+        preview: (templateId: string, variables: Record<string, string>, options?: RequestOptions) => Promise<{
+            preview_html: string;
+        }>;
+        /**
+         * Publish a template — compiles MJML, creates an immutable TemplateVersion snapshot,
+         * and updates `published_body_html`. Campaigns created after this call use this version.
+         *
+         * @param templateId - The ID of the template to publish.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the updated template with `current_version` incremented.
+         *
+         * @example
+         * ```typescript
+         * const template = await client.campaigns.templates.publish("tmpl_123");
+         * console.log(template.current_version); // 1
+         * ```
+         */
+        publish: (templateId: string, options?: RequestOptions) => Promise<EmailMarketingTemplate>;
+        /**
+         * Unpublish a template — reverts to draft state.
+         *
+         * @param templateId - The ID of the template to unpublish.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the updated template in draft state.
+         *
+         * @example
+         * ```typescript
+         * await client.campaigns.templates.unpublish("tmpl_123");
+         * ```
+         */
+        unpublish: (templateId: string, options?: RequestOptions) => Promise<EmailMarketingTemplate>;
+        /**
+         * Restore a template's MJML source from a previous version snapshot.
+         * Does NOT auto-publish — call `publish` after reviewing the restored content.
+         *
+         * @param templateId - The ID of the template to roll back.
+         * @param versionNumber - The version number to restore from.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the template with MJML source restored.
+         *
+         * @example
+         * ```typescript
+         * const template = await client.campaigns.templates.rollback("tmpl_123", 2);
+         * ```
+         */
+        rollback: (templateId: string, versionNumber: number, options?: RequestOptions) => Promise<EmailMarketingTemplate>;
+        /**
+         * List all TemplateVersion snapshots for a template, ordered by version_number descending.
+         * Body fields (body_html, body_mjml) are excluded for performance. Use getVersion for full content.
+         *
+         * @param templateId - The ID of the template whose versions to list.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to an array of version summaries (without body fields).
+         *
+         * @example
+         * ```typescript
+         * const versions = await client.campaigns.templates.versions("tmpl_123");
+         * ```
+         */
+        versions: (templateId: string, options?: RequestOptions) => Promise<Omit<TemplateVersion, "body_html" | "body_mjml">[]>;
+        /**
+         * Fetch a specific TemplateVersion by template ID and version number.
+         *
+         * @param templateId - The ID of the template.
+         * @param versionNumber - The version number to fetch.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the full {@link TemplateVersion} including body fields.
+         *
+         * @example
+         * ```typescript
+         * const v = await client.campaigns.templates.getVersion("tmpl_123", 2);
+         * ```
+         */
+        getVersion: (templateId: string, versionNumber: number, options?: RequestOptions) => Promise<TemplateVersion>;
+    };
+    /**
+     * Generated Emails — AI-personalised email drafts awaiting human review.
+     *
+     * When a campaign uses AI personalisation, the platform generates an
+     * individual email draft for each recipient. These drafts sit in a review
+     * queue until a human approves them. Approved emails are moved to the
+     * sending queue and dispatched automatically.
+     */
+    generatedEmails: {
+        /**
+         * Fetch a single AI-generated email draft by its unique ID.
+         *
+         * @param id - The unique identifier of the generated email to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link EmailMarketingGeneratedEmail}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const email = await client.campaigns.generatedEmails.get('gen_abc123');
+         * console.log(email.attributes.subject, email.attributes.body_html);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<EmailMarketingGeneratedEmail>;
+        /**
+         * Update an AI-generated email draft before approval.
+         *
+         * Use this to correct the AI output — adjust subject lines, body copy,
+         * or personalisation tokens — before approving the email for sending.
+         *
+         * @param id - The unique identifier of the generated email to update.
+         * @param attributes - Key/value map of attributes to change (e.g.
+         *   `subject`, `body_html`, `body_text`).
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingGeneratedEmail}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const email = await client.campaigns.generatedEmails.update('gen_abc123', {
+         *   subject: 'Personalised just for you, Jane',
+         *   body_html: '<p>Hi Jane, ...</p>',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateGeneratedEmailAttributes, options?: RequestOptions) => Promise<EmailMarketingGeneratedEmail>;
+        /**
+         * Approve a generated email draft and move it to the sending queue.
+         *
+         * Once approved, the email is scheduled for delivery to its intended
+         * recipient and can no longer be edited. If you need to make changes,
+         * call {@link update} first, then approve.
+         *
+         * @param id - The unique identifier of the generated email to approve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingGeneratedEmail}
+         *   with `status` reflecting its new approved/queued state.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const approved = await client.campaigns.generatedEmails.approve('gen_abc123');
+         * console.log(approved.attributes.status); // 'queued'
+         * ```
+         */
+        approve: (id: string, options?: RequestOptions) => Promise<EmailMarketingGeneratedEmail>;
+        /**
+         * Reject an AI-generated email draft. The email will not be sent.
+         *
+         * @param id - The unique identifier of the generated email to reject.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingGeneratedEmail}.
+         *
+         * @example
+         * ```typescript
+         * const rejected = await client.campaigns.generatedEmails.reject('gen_abc123');
+         * console.log(rejected.attributes.status); // 'rejected'
+         * ```
+         */
+        reject: (id: string, options?: RequestOptions) => Promise<EmailMarketingGeneratedEmail>;
+        /**
+         * Schedule a generated email for delivery at a specific time.
+         *
+         * @param id - The unique identifier of the generated email to schedule.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingGeneratedEmail}.
+         *
+         * @example
+         * ```typescript
+         * const scheduled = await client.campaigns.generatedEmails.schedule('gen_abc123');
+         * ```
+         */
+        schedule: (id: string, options?: RequestOptions) => Promise<EmailMarketingGeneratedEmail>;
+        /**
+         * List all generated emails for a specific campaign.
+         *
+         * @param campaignId - The ID of the campaign whose generated emails to list.
+         * @param options - Optional pagination controls and request-level overrides.
+         * @returns A promise resolving to an array of {@link EmailMarketingGeneratedEmail}.
+         *
+         * @example
+         * ```typescript
+         * const emails = await client.campaigns.generatedEmails.listByCampaign('camp_abc');
+         * console.log(`${emails.length} emails generated`);
+         * ```
+         */
+        listByCampaign: (campaignId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<EmailMarketingGeneratedEmail[]>;
+    };
+    /**
+     * Sender Profiles — verified from-address identities for outgoing email.
+     *
+     * A sender profile defines the `From` name and email address used when
+     * sending campaigns. Before a profile can be used for sending, its domain
+     * must be verified via DNS records (SPF, DKIM, DMARC). Use
+     * {@link validateDns} to trigger re-verification after DNS changes.
+     */
+    senderProfiles: {
+        /**
+         * Fetch a single sender profile by its unique ID.
+         *
+         * @param id - The unique identifier of the sender profile to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link EmailMarketingSenderProfile}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const profile = await client.campaigns.senderProfiles.get('sp_abc123');
+         * console.log(profile.attributes.from_email, profile.attributes.dns_verified);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<EmailMarketingSenderProfile>;
+        /**
+         * Update an existing sender profile's attributes.
+         *
+         * After updating `from_email` or `from_name`, re-verify DNS with
+         * {@link validateDns} to ensure deliverability.
+         *
+         * @param id - The unique identifier of the sender profile to update.
+         * @param attributes - Key/value map of attributes to change (e.g.
+         *   `from_name`, `reply_to_email`).
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingSenderProfile}.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const profile = await client.campaigns.senderProfiles.update('sp_abc123', {
+         *   from_name: 'Acme Support Team',
+         *   reply_to_email: 'support@acme.com',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateSenderProfileAttributes, options?: RequestOptions) => Promise<EmailMarketingSenderProfile>;
+        /**
+         * Validate the DNS records (SPF, DKIM, DMARC) for a sender profile.
+         *
+         * Triggers a re-check of the domain's DNS configuration. The result
+         * indicates which records are correctly published and which are missing
+         * or misconfigured. Call this after making DNS changes to confirm the
+         * domain is ready for sending.
+         *
+         * @param id - The unique identifier of the sender profile to validate.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the DNS validation result payload,
+         *   containing per-record status information.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const result = await client.campaigns.senderProfiles.validateDns('sp_abc123');
+         * // result contains spf, dkim, dmarc status fields
+         * console.log(result);
+         * ```
+         */
+        validateDns: (id: string, options?: RequestOptions) => Promise<EmailMarketingSenderProfile>;
+        /**
+         * Permanently delete a sender profile.
+         *
+         * Deleting a sender profile that is referenced by existing campaigns will
+         * cause those campaigns to require a new profile before they can be sent.
+         *
+         * @param id - The unique identifier of the sender profile to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * await client.campaigns.senderProfiles.delete('sp_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Sequences — multi-step drip campaign automation.
+     *
+     * A sequence is a timed series of emails automatically sent to enrolled
+     * contacts over days or weeks (e.g. a 5-email onboarding drip). Each step
+     * in the sequence has a delay and references a template or inline content.
+     * Sequences can be paused and resumed without losing enrollee state.
+     */
+    sequences: {
+        /**
+         * Fetch a single sequence by its unique ID.
+         *
+         * @param id - The unique identifier of the sequence to retrieve.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the matching {@link EmailMarketingSequence}.
+         *
+         * @example
+         * ```typescript
+         * const sequence = await client.campaigns.sequences.get('seq_abc123');
+         * console.log(sequence.attributes.name, sequence.attributes.status);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<EmailMarketingSequence>;
+        /**
+         * Create a new email sequence.
+         *
+         * @param attributes - Key/value map of sequence attributes. Must include
+         *   `workspace_id` and `name`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the newly created sequence resource.
+         *
+         * @example
+         * ```typescript
+         * const sequence = await client.campaigns.sequences.create({
+         *   workspace_id: 'ws_abc123',
+         *   name: 'New User Onboarding',
+         * });
+         * ```
+         */
+        create: (attributes: CreateSequenceAttributes, options?: RequestOptions) => Promise<EmailMarketingSequence>;
+        /**
+         * Update an existing sequence's attributes (PATCH semantics).
+         *
+         * @param id - The unique identifier of the sequence to update.
+         * @param attributes - Key/value map of attributes to change.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingSequence}.
+         *
+         * @example
+         * ```typescript
+         * const updated = await client.campaigns.sequences.update('seq_abc', { name: 'Revised Drip' });
+         * ```
+         */
+        update: (id: string, attributes: UpdateSequenceAttributes, options?: RequestOptions) => Promise<EmailMarketingSequence>;
+        /**
+         * Permanently delete a sequence.
+         *
+         * @param id - The unique identifier of the sequence to delete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * await client.campaigns.sequences.delete('seq_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * Activate a sequence to start delivering emails to enrolled contacts.
+         *
+         * @param id - The unique identifier of the sequence to activate.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingSequence}.
+         *
+         * @example
+         * ```typescript
+         * const active = await client.campaigns.sequences.activate('seq_abc123');
+         * console.log(active.attributes.status); // 'active'
+         * ```
+         */
+        activate: (id: string, options?: RequestOptions) => Promise<EmailMarketingSequence>;
+        /**
+         * Pause a running sequence, suspending all pending deliveries.
+         *
+         * @param id - The unique identifier of the sequence to pause.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingSequence}.
+         *
+         * @example
+         * ```typescript
+         * const paused = await client.campaigns.sequences.pause('seq_abc123');
+         * console.log(paused.attributes.status); // 'paused'
+         * ```
+         */
+        pause: (id: string, options?: RequestOptions) => Promise<EmailMarketingSequence>;
+        /**
+         * Mark a sequence as complete, finalizing all deliveries.
+         *
+         * @param id - The unique identifier of the sequence to complete.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated {@link EmailMarketingSequence}.
+         *
+         * @example
+         * ```typescript
+         * const completed = await client.campaigns.sequences.complete('seq_abc123');
+         * ```
+         */
+        complete: (id: string, options?: RequestOptions) => Promise<EmailMarketingSequence>;
+        /**
+         * List all sequences for a workspace with optional pagination.
+         *
+         * @param workspaceId - The ID of the workspace whose sequences to list.
+         * @param options - Optional pagination controls (`page`, `pageSize`) and
+         *   request-level overrides.
+         * @returns A promise that resolves to an array of sequence resource records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const sequences = await client.campaigns.sequences.listByWorkspace('ws_abc123');
+         * console.log(sequences);
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<EmailMarketingSequence[]>;
+        /**
+         * Resume a paused sequence, re-enabling automatic step delivery for all
+         * currently enrolled contacts from where they left off.
+         *
+         * Sequences may be paused by the platform (e.g. due to a sending limit)
+         * or manually by an ISV admin. Resuming does not re-send skipped steps;
+         * it continues from the next scheduled step for each enrollee.
+         *
+         * @param id - The unique identifier of the sequence to resume.
+         * @param options - Optional request-level overrides.
+         * @returns A promise that resolves to the updated sequence resource.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * const sequence = await client.campaigns.sequences.resume('seq_abc123');
+         * console.log(sequence); // sequence with status: 'active'
+         * ```
+         */
+        resume: (id: string, options?: RequestOptions) => Promise<EmailMarketingSequence>;
+    };
+    /**
+     * Recipients — campaign audience members.
+     *
+     * Each recipient represents one email address on a campaign's send list,
+     * with optional merge fields for personalisation. Recipients are typically
+     * imported via CSV.
+     */
+    recipients: {
+        /**
+         * Fetch a single recipient by its unique ID.
+         *
+         * @param id - The unique identifier of the recipient.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the recipient record.
+         *
+         * @example
+         * ```typescript
+         * const recipient = await client.campaigns.recipients.get('recip_abc123');
+         * console.log(recipient.attributes.email);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /**
+         * List all recipients for a specific campaign.
+         *
+         * @param campaignId - The ID of the campaign whose recipients to list.
+         * @param options - Optional pagination controls and request-level overrides.
+         * @returns A promise resolving to an array of recipient records.
+         *
+         * @example
+         * ```typescript
+         * const recipients = await client.campaigns.recipients.listByCampaign('camp_abc');
+         * console.log(`${recipients.length} recipients`);
+         * ```
+         */
+        listByCampaign: (campaignId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Record<string, unknown>[]>;
+    };
+    /**
+     * Sequence Steps — individual steps within a drip sequence.
+     *
+     * Each step defines a timed email delivery within a sequence, with a
+     * delay offset and template or inline content.
+     */
+    sequenceSteps: {
+        /**
+         * Fetch a single sequence step by its unique ID.
+         *
+         * @param id - The unique identifier of the sequence step.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the sequence step record.
+         *
+         * @example
+         * ```typescript
+         * const step = await client.campaigns.sequenceSteps.get('step_abc123');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /**
+         * Create a new step within a sequence.
+         *
+         * @param attributes - Step attributes including `sequence_id`.
+         * @param options - Optional request-level overrides.
+         * @returns A promise resolving to the newly created sequence step.
+         *
+         * @example
+         * ```typescript
+         * const step = await client.campaigns.sequenceSteps.create({
+         *   sequence_id: 'seq_abc123',
+         *   delay_days: 3,
+         *   template_id: 'tmpl_reminder',
+         * });
+         * ```
+         */
+        create: (attributes: CreateSequenceStepAttributes, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /**
+         * List all steps in a specific sequence.
+         *
+         * @param sequenceId - The ID of the sequence whose steps to list.
+         * @param options - Optional pagination controls and request-level overrides.
+         * @returns A promise resolving to an array of sequence step records.
+         *
+         * @example
+         * ```typescript
+         * const steps = await client.campaigns.sequenceSteps.listBySequence('seq_abc123');
+         * ```
+         */
+        listBySequence: (sequenceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Record<string, unknown>[]>;
+    };
+};
+//# sourceMappingURL=campaigns.d.ts.map