@gpt-platform/client 0.10.4 → 0.11.0

package/dist/namespaces/platform.d.ts

@@ -0,0 +1,1430 @@
+import type { Application, BrandIdentity, Invitation, Permission, PermissionPreset, PlatformTone, Role, Tenant, Workspace } from "../_internal/types.gen";
+/** Attributes accepted when updating a workspace (PATCH semantics). */
+export type UpdateWorkspaceAttributes = {
+    name?: string;
+    slug?: string;
+    description?: string;
+    deduplicate_uploads?: boolean;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating an application. */
+export type CreateApplicationAttributes = {
+    name: string;
+    owner_id?: string;
+    slug?: string;
+    base_url?: string;
+    workspace_mode?: "single" | "multi";
+    enabled_capabilities?: string[];
+    allow_org_creation?: boolean;
+    invitation_mode?: "open" | "admin_only";
+    max_parallel_tools_global?: number;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating an application (PATCH semantics). */
+export type UpdateApplicationAttributes = {
+    name?: string;
+    slug?: string;
+    base_url?: string;
+    workspace_mode?: "single" | "multi";
+    enabled_capabilities?: string[];
+    allow_org_creation?: boolean;
+    invitation_mode?: "open" | "admin_only";
+    max_parallel_tools_global?: number;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a tenant. */
+export type CreateTenantAttributes = {
+    name: string;
+    slug?: string;
+    owner_id?: string;
+    application_id?: string;
+    kind?: string;
+    logo_url?: string;
+    badge_url?: string;
+    plan_tier?: string;
+    is_personal?: boolean;
+    vanity_slug?: string;
+    description?: string;
+    contact_email?: string;
+    contact_phone?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a tenant (PATCH semantics). */
+export type UpdateTenantAttributes = {
+    name?: string;
+    slug?: string;
+    logo_url?: string;
+    badge_url?: string;
+    vanity_slug?: string;
+    plan_tier?: string;
+    description?: string;
+    contact_email?: string;
+    contact_phone?: string;
+    [key: string]: unknown;
+};
+/**
+ * Attributes accepted when creating an invitation.
+ *
+ * Invitations target a scope: either a tenant or a workspace.
+ * Use `scope_type` + `scope_id` to specify the target, or use
+ * the convenience shorthand `workspace_id` or `tenant_id`.
+ */
+export type CreateInvitationAttributes = {
+    email: string;
+    role: "admin" | "member" | "editor" | "viewer";
+    custom_message?: string;
+    permissions?: string[];
+    application_id?: string;
+    /** Shorthand: invite to a workspace. Sets scope_type: "workspace", scope_id: workspace_id */
+    workspace_id?: string;
+    /** Shorthand: invite to a tenant. Sets scope_type: "tenant", scope_id: tenant_id */
+    tenant_id?: string;
+    /** Explicit scope type (alternative to workspace_id/tenant_id shorthand) */
+    scope_type?: "tenant" | "workspace";
+    /** Explicit scope ID (use with scope_type) */
+    scope_id?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a brand identity. */
+export type CreateBrandIdentityAttributes = {
+    /** Required. Display name for this brand identity. */
+    name: string;
+    /** Tenant UUID — required for tenant-scoped identities. */
+    tenant_id: string;
+    /** Optional workspace UUID — set for workspace-level overrides, omit for tenant-level. */
+    workspace_id?: string;
+    /** Brand voice description (e.g. "Professional but approachable"). */
+    voice?: string;
+    /** Brand values as an array of strings (e.g. ["innovation", "integrity"]). */
+    values?: string[];
+    /** Target audience description. */
+    target_audience?: string;
+    /** Industry vertical. */
+    industry?: string;
+    /** Brand website URL. */
+    website_url?: string;
+    /** Logo image URL. */
+    logo_url?: string;
+    /** Color palette map (e.g. { primary: "#0066CC", secondary: "#FF0000" }). */
+    color_palette?: Record<string, string>;
+    /** General description of this brand identity. */
+    description?: string;
+    /** Whether this is the default identity at its scope level. */
+    is_default?: boolean;
+};
+/** Attributes accepted when updating a brand identity (PATCH semantics). */
+export type UpdateBrandIdentityAttributes = Partial<Omit<CreateBrandIdentityAttributes, "workspace_id" | "tenant_id">>;
+/** Attributes accepted when creating a platform tone. */
+export type CreatePlatformToneAttributes = {
+    /** Required. Social platform this tone applies to. */
+    platform: "facebook" | "instagram" | "threads" | "twitter" | "linkedin" | "reddit" | "bluesky";
+    /** Required. Brand identity UUID this tone belongs to. */
+    brand_identity_id: string;
+    /** Tone preset. Default: "casual". */
+    tone?: "casual" | "professional" | "humorous" | "inspirational" | "educational" | "promotional";
+    /** Emoji usage policy. Default: "minimal". */
+    emoji_policy?: "none" | "minimal" | "moderate" | "heavy";
+    /** Number of hashtags to include. Default: 5. */
+    hashtag_count?: number;
+    /** Maximum character length for posts on this platform. */
+    max_length?: number;
+    /** Call-to-action text to include in generated copy. */
+    call_to_action?: string;
+    /** Free-form instructions for AI content generation on this platform. */
+    custom_instructions?: string;
+};
+/** Attributes accepted when updating a platform tone (PATCH semantics). */
+export type UpdatePlatformToneAttributes = Partial<Omit<CreatePlatformToneAttributes, "brand_identity_id" | "platform">>;
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+/**
+ * Creates the platform namespace providing access to workspace management,
+ * application configuration, tenant administration, workspace invitations,
+ * member management, and application-level config entries.
+ *
+ * Access via `client.platform`.
+ *
+ * @example
+ * ```typescript
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ * const workspaces = await client.platform.workspaces.list();
+ * ```
+ */
+export declare function createPlatformNamespace(rb: RequestBuilder): {
+    /**
+     * Workspaces — the primary data isolation boundary.
+     *
+     * All resources (documents, agents, results, etc.) belong to a workspace.
+     * The current user's accessible workspaces depend on their memberships
+     * and the application's `workspace_mode` (`"single"` or `"multi"`).
+     */
+    workspaces: {
+        /**
+         * List all workspaces the current user has access to.
+         *
+         * Returns workspaces across all memberships (owned and shared).
+         * Equivalent to the union of `mine` and `shared`.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `Workspace` records accessible to the current user.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const workspaces = await client.platform.workspaces.list();
+         * workspaces.forEach(w => console.log(w.attributes?.name));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Workspace[]>;
+        /**
+         * List workspaces owned by the currently authenticated user.
+         *
+         * Returns only workspaces for which the current user is the primary owner.
+         * Does not include workspaces where the user is a member but not the owner.
+         *
+         * @param options - Optional request options.
+         * @returns An array of `Workspace` records owned by the current user.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const mine = await client.platform.workspaces.mine();
+         * ```
+         */
+        mine: (options?: RequestOptions) => Promise<Workspace[]>;
+        /**
+         * List workspaces shared with the currently authenticated user.
+         *
+         * Returns workspaces where the current user has been granted membership
+         * by another owner. Does not include workspaces the user owns.
+         *
+         * @param options - Optional request options.
+         * @returns An array of `Workspace` records shared with the current user.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const shared = await client.platform.workspaces.shared();
+         * shared.forEach(w => console.log(w.attributes?.name));
+         * ```
+         */
+        shared: (options?: RequestOptions) => Promise<Workspace[]>;
+        /**
+         * Retrieve a single workspace by its ID.
+         *
+         * @param id - The UUID of the workspace.
+         * @param options - Optional request options.
+         * @returns The matching `Workspace`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const workspace = await client.platform.workspaces.get('ws_abc123');
+         * console.log(workspace.attributes?.name, workspace.attributes?.slug);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<Workspace>;
+        /**
+         * Create a new workspace.
+         *
+         * Creates a workspace under the current tenant. The `name` is required;
+         * `slug` is optional and will be auto-generated from the name if omitted.
+         * In applications with `workspace_mode: "single"`, a default workspace
+         * is created automatically at tenant provisioning time — manual creation
+         * is only needed in `"multi"` mode.
+         *
+         * @param name - Human-readable workspace name.
+         * @param slug - Optional URL-friendly slug. Auto-generated if omitted.
+         * @param options - Optional request options.
+         * @returns The newly created `Workspace`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const workspace = await client.platform.workspaces.create(
+         *   'Clinical Team — East Wing',
+         *   'clinical-east',
+         * );
+         * console.log(workspace.id);
+         * ```
+         */
+        create: (name: string, slug?: string, options?: RequestOptions) => Promise<Workspace>;
+        /**
+         * List extraction exports for a specific workspace (paginated).
+         *
+         * Returns one page of export records associated with the given workspace.
+         * Prefer `client.extraction.exports.list` for extraction-specific workflows;
+         * this method is provided here for workspace-centric views.
+         *
+         * @param workspaceId - The UUID of the workspace to list exports for.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of export records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const exports = await client.platform.workspaces.listExtractionExportsByWorkspace('ws_abc123');
+         * ```
+         */
+        listExtractionExportsByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Workspace[]>;
+        /**
+         * List all extraction exports for a workspace, auto-paginating through every page.
+         *
+         * @param workspaceId - The UUID of the workspace to list exports for.
+         * @param options - Optional request options.
+         * @returns All export records for the workspace as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allExports = await client.platform.workspaces.listAllExtractionExportsByWorkspace('ws_abc123');
+         * ```
+         */
+        listAllExtractionExportsByWorkspace: (workspaceId: string, options?: RequestOptions) => Promise<Workspace[]>;
+        /**
+         * Delete a workspace.
+         *
+         * Permanently removes the workspace and all data it contains (documents,
+         * results, agents, etc.). This operation is irreversible. Deletion may
+         * be asynchronous — the workspace may be scheduled for purge rather than
+         * deleted immediately.
+         *
+         * @param id - The UUID of the workspace to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion or scheduling.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.platform.workspaces.delete('ws_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * Update workspace settings.
+         *
+         * Currently used to update storage settings (e.g., custom storage bucket,
+         * retention overrides) via the `storage_settings` attribute. Also accepts
+         * general workspace attributes like `name` and `slug`.
+         *
+         * @param id - The UUID of the workspace to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `Workspace`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const workspace = await client.platform.workspaces.update('ws_abc123', {
+         *   name: 'Clinical Team — West Wing',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateWorkspaceAttributes, options?: RequestOptions) => Promise<Workspace>;
+        /**
+         * Update storage-specific settings for a workspace.
+         *
+         * Updates the embedded storage settings (e.g., deduplication,
+         * upload limits) without touching other workspace attributes.
+         *
+         * @param id - The UUID of the workspace.
+         * @param settings - Storage settings to update.
+         * @param options - Optional request options.
+         * @returns The updated `Workspace`.
+         */
+        updateStorageSettings: (id: string, settings: Record<string, unknown>, options?: RequestOptions) => Promise<Workspace>;
+        /**
+         * Allocate credits to a workspace.
+         *
+         * Triggers a credit allocation operation for the specified workspace,
+         * drawing from the tenant's credit pool. The resulting workspace record
+         * reflects the updated credit balance.
+         *
+         * @param workspaceId - The UUID of the workspace to allocate credits for.
+         * @param amount - Number of credits to allocate (max 100,000 per call).
+         * @param options - Optional request options.
+         * @returns The updated `Workspace` after allocation.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const workspace = await client.platform.workspaces.allocateCredits('ws_abc123', 5000);
+         * ```
+         */
+        allocateCredits: (workspaceId: string, amount: number, options?: RequestOptions) => Promise<Workspace>;
+        /**
+         * Populate content hashes for all documents in a workspace.
+         *
+         * Triggers a backfill operation that computes and stores content
+         * hashes for documents that were created before hash-on-upload
+         * was enabled. This is an idempotent operation — documents that
+         * already have hashes are skipped.
+         *
+         * @param workspaceId - The UUID of the workspace to populate hashes for.
+         * @param options - Optional request options.
+         * @returns The updated `Workspace`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const workspace = await client.platform.workspaces.populateHashes('ws_abc123');
+         * ```
+         */
+        populateHashes: (workspaceId: string, options?: RequestOptions) => Promise<Workspace>;
+    };
+    /**
+     * Applications — ISV application management.
+     *
+     * Applications are the top-level ISV product identity. Each application
+     * has its own branding, API keys, plan catalog, and configuration. A
+     * single ISV may operate multiple applications (e.g., one per product or
+     * market segment).
+     */
+    applications: {
+        /**
+         * List all applications accessible to the current actor.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `Application` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const apps = await client.platform.applications.list();
+         * apps.forEach(a => console.log(a.attributes?.name));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Application[]>;
+        /**
+         * Delete an application.
+         *
+         * Permanently removes the application and all associated tenants,
+         * workspaces, and data. This is irreversible and should only be
+         * performed after confirming with all affected parties.
+         *
+         * @param id - The UUID of the application to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.platform.applications.delete('app_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * Create a new application.
+         *
+         * Typical attributes: `name`, `slug`, `workspace_mode` (`"single"` or
+         * `"multi"`), and branding config. The application is provisioned with
+         * a default plan and API key set.
+         *
+         * @param attributes - Application creation attributes. `name` is required.
+         * @param options - Optional request options.
+         * @returns The newly created `Application`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const app = await client.platform.applications.create({
+         *   name: 'HealthHub Patient Portal',
+         *   slug: 'healthhub',
+         *   workspace_mode: 'multi',
+         * });
+         * console.log(app.id);
+         * ```
+         */
+        create: (attributes: CreateApplicationAttributes, options?: RequestOptions) => Promise<Application>;
+        /**
+         * Update an application's configuration.
+         *
+         * Use to change the application's name, branding, plan settings,
+         * or credit allocation configuration.
+         *
+         * @param id - The UUID of the application to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `Application`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const app = await client.platform.applications.update('app_abc123', {
+         *   name: 'HealthHub — Enterprise',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateApplicationAttributes, options?: RequestOptions) => Promise<Application>;
+        /**
+         * Retrieve a single application by its ID.
+         *
+         * @param id - The UUID of the application.
+         * @param options - Optional request options.
+         * @returns The matching `Application`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const app = await client.platform.applications.get('app_abc123');
+         * console.log(app.attributes?.name, app.attributes?.workspace_mode);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<Application>;
+        /**
+         * Get the application scoped to the current `x-application-key` request header.
+         *
+         * Useful when you have an API key and want to retrieve the application
+         * context it belongs to, without knowing the application's UUID upfront.
+         * The response is derived from the key used to authenticate the request.
+         *
+         * @param options - Optional request options.
+         * @returns The `Application` associated with the current API key.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const currentApp = await client.platform.applications.readCurrent();
+         * console.log(currentApp.attributes?.name);
+         * ```
+         */
+        readCurrent: (options?: RequestOptions) => Promise<Application>;
+        /**
+         * Fetch an application by its unique slug.
+         *
+         * Looks up an application using its URL-friendly slug identifier
+         * rather than its UUID. Useful for public-facing flows where the
+         * slug is known (e.g., from a vanity URL).
+         *
+         * @param slug - The application slug (e.g., `"my-saas-app"`).
+         * @param options - Optional request options.
+         * @returns The matching `Application`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const app = await client.platform.applications.getBySlug('my-saas-app');
+         * console.log(app.attributes?.name);
+         * ```
+         */
+        getBySlug: (slug: string, options?: RequestOptions) => Promise<Application>;
+    };
+    /**
+     * Tenants — customer organization management.
+     *
+     * Tenants represent customer organizations within an application. Each
+     * tenant owns its own billing account, membership roster, and workspace(s).
+     * ISVs provision tenants when onboarding new customers.
+     */
+    tenants: {
+        /**
+         * List all tenants (paginated).
+         *
+         * Returns tenants accessible to the current actor (application-scoped).
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `Tenant` records.
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Tenant[]>;
+        /**
+         * List document statistics for tenants (paginated).
+         *
+         * Returns per-tenant document usage metrics, useful for billing
+         * dashboards and usage monitoring at the ISV level.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of tenant document stat records (typed as `Tenant[]`).
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const stats = await client.platform.tenants.listDocumentStats();
+         * stats.forEach(s => console.log(s.attributes?.document_count));
+         * ```
+         */
+        listDocumentStats: (tenantId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Tenant[]>;
+        /**
+         * List all document statistics for tenants, auto-paginating.
+         *
+         * @param tenantId - The UUID of the tenant.
+         * @param options - Optional request options.
+         * @returns All tenant document stat records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allStats = await client.platform.tenants.listAllDocumentStats('tenant_abc123');
+         * ```
+         */
+        listAllDocumentStats: (tenantId: string, options?: RequestOptions) => Promise<Tenant[]>;
+        /**
+         * Allocate credits to a tenant's liability account.
+         *
+         * Adds credits to the tenant's billing account, drawn from the
+         * application's credit pool. Used by ISVs to grant prepaid usage
+         * allowances to their customers.
+         *
+         * @param id - The UUID of the tenant to credit.
+         * @param options - Optional request options.
+         * @returns The updated `Tenant` with new credit balance.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tenant = await client.platform.tenants.credit('tenant_abc123');
+         * console.log(tenant.attributes?.credit_balance);
+         * ```
+         */
+        credit: (id: string, amount: number, description?: string, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Deactivate a tenant (hide from user's account).
+         *
+         * Sets `deactivated_at` on the tenant. The tenant and its workspaces
+         * disappear from `workspaces.mine()` and tenant listings. Billing and
+         * data are completely unaffected. Reversible via `reactivate()`.
+         *
+         * Only the tenant owner can deactivate.
+         *
+         * @param id - The UUID of the tenant to deactivate.
+         * @param options - Optional request options.
+         * @returns The updated tenant record.
+         *
+         * @example
+         * ```typescript
+         * await client.platform.tenants.deactivate('tenant_abc123');
+         * ```
+         */
+        deactivate: (id: string, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Reactivate a previously deactivated tenant.
+         *
+         * Clears `deactivated_at`, restoring the tenant and its workspaces
+         * to the user's account. Only works on deactivated tenants.
+         *
+         * Only the tenant owner can reactivate.
+         *
+         * @param id - The UUID of the tenant to reactivate.
+         * @param options - Optional request options.
+         * @returns The updated tenant record.
+         *
+         * @example
+         * ```typescript
+         * await client.platform.tenants.reactivate('tenant_abc123');
+         * ```
+         */
+        reactivate: (id: string, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Create a new tenant (ISV provisioning flow).
+         *
+         * Provisions a new customer tenant under the current application.
+         * Typical attributes: `name`, `email`, `plan_id`. The platform
+         * automatically creates the tenant's default workspace and billing
+         * account upon creation.
+         *
+         * @param attributes - Tenant creation attributes. `name` and `email` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `Tenant`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tenant = await client.platform.tenants.create({
+         *   name: 'Acme Medical Group',
+         *   email: 'billing@acme-medical.com',
+         *   plan_id: 'plan_professional',
+         * });
+         * console.log('Tenant provisioned:', tenant.id);
+         * ```
+         */
+        create: (attributes: CreateTenantAttributes, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Update a tenant's details.
+         *
+         * Use to update the tenant's name, contact email, plan assignment,
+         * or other configurable attributes.
+         *
+         * @param id - The UUID of the tenant to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `Tenant`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tenant = await client.platform.tenants.update('tenant_abc123', {
+         *   name: 'Acme Medical Group LLC',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateTenantAttributes, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Schedule a tenant for data purge.
+         *
+         * Marks the tenant for deferred deletion. The platform will retain
+         * data for a configurable grace period (for export purposes) before
+         * permanently purging all records. Use this for compliant off-boarding
+         * rather than immediate `delete`.
+         *
+         * @param id - The UUID of the tenant to schedule for purge.
+         * @param options - Optional request options.
+         * @returns The updated `Tenant` with `purge_scheduled_at` populated.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tenant = await client.platform.tenants.schedulePurge('tenant_abc123');
+         * console.log('Purge scheduled for:', tenant.attributes?.purge_scheduled_at);
+         * ```
+         */
+        schedulePurge: (id: string, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Retrieve a single tenant by its ID.
+         *
+         * @param id - The UUID of the tenant.
+         * @param options - Optional request options.
+         * @returns The matching `Tenant`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tenant = await client.platform.tenants.get('tenant_abc123');
+         * console.log(tenant.attributes?.name, tenant.attributes?.plan_id);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Transfer ownership of a tenant to another admin member.
+         *
+         * The new owner must already be a tenant admin. The previous owner
+         * retains their admin role. Cannot be used on personal tenants.
+         *
+         * @param tenantId - The UUID of the tenant to transfer.
+         * @param newOwnerId - The UUID of the user to become the new owner.
+         * @param options - Optional request options.
+         * @returns The updated `Tenant`.
+         */
+        transferOwnership: (tenantId: string, newOwnerId: string, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Convert a personal tenant to an organization.
+         *
+         * Flips `is_personal` to `false`, sets a new name and slug, and
+         * provisions a default workspace if `application_id` is provided.
+         * Only the tenant owner can perform this action.
+         *
+         * @param tenantId - The UUID of the personal tenant to convert.
+         * @param attributes - Conversion attributes. `name` is required; `slug` and `application_id` are optional.
+         * @param options - Optional request options.
+         * @returns The converted `Tenant`.
+         *
+         * @example
+         * ```typescript
+         * const org = await client.platform.tenants.convertToOrg(tenantId, {
+         *   name: "My Company",
+         * });
+         * console.log(org.is_personal); // false
+         * ```
+         */
+        convertToOrg: (tenantId: string, attributes: {
+            name: string;
+            slug?: string;
+            application_id?: string;
+        }, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Create a new organization tenant.
+         *
+         * Requires the application to have `allow_org_creation` enabled.
+         * Provisions a workspace, billing accounts, and storage for the new org.
+         *
+         * @param attributes - Org creation attributes. `name` is required.
+         * @param options - Optional request options.
+         * @returns The newly created organization `Tenant`.
+         */
+        createOrg: (attributes: {
+            name: string;
+            logo_url?: string;
+            [key: string]: unknown;
+        }, options?: RequestOptions) => Promise<Tenant>;
+        /**
+         * Create a personal tenant for the current user.
+         *
+         * Each user may have at most one personal tenant. Name and slug are
+         * auto-generated from the user's email.
+         *
+         * @param options - Optional request options.
+         * @returns The newly created personal `Tenant`.
+         */
+        createPersonal: (options?: RequestOptions) => Promise<Tenant>;
+    };
+    /**
+     * Invitations — workspace and application invitations for the current user.
+     */
+    invitations: {
+        /**
+         * Accept a pending invitation (authenticated user flow).
+         *
+         * Accepts an invitation the current user received, creating
+         * the appropriate membership records.
+         *
+         * @param id - The UUID of the invitation to accept.
+         * @param options - Optional request options.
+         * @returns The updated `Invitation`.
+         */
+        accept: (id: string, token: string, options?: RequestOptions) => Promise<Invitation>;
+        /**
+         * Decline a pending invitation.
+         *
+         * The invitation status is set to `:declined` and no membership is created.
+         *
+         * @param id - The UUID of the invitation to decline.
+         * @param options - Optional request options.
+         * @returns The updated `Invitation`.
+         */
+        decline: (id: string, options?: RequestOptions) => Promise<Invitation>;
+        /**
+         * Revoke a pending invitation (inviter flow).
+         *
+         * Cancels the invitation so it can no longer be accepted or declined.
+         * Callable by the original inviter or a tenant admin.
+         *
+         * @param id - The UUID of the invitation to revoke.
+         * @param options - Optional request options.
+         * @returns The updated `Invitation`.
+         */
+        revoke: (id: string, options?: RequestOptions) => Promise<Invitation>;
+        /**
+         * List pending invitations for the currently authenticated user (paginated).
+         *
+         * Returns workspace and application invitations that have been sent to
+         * the current user and are awaiting a response.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `Invitation` records for the current user.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const invites = await client.platform.invitations.listMe();
+         * invites.forEach(i => console.log(i.attributes?.workspace_name, i.attributes?.role));
+         * ```
+         */
+        listMe: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Invitation[]>;
+        /**
+         * List all pending invitations for the current user, auto-paginating.
+         *
+         * @param options - Optional request options.
+         * @returns All pending `Invitation` records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const allInvites = await client.platform.invitations.listAllMe();
+         * ```
+         */
+        listAllMe: (options?: RequestOptions) => Promise<Invitation[]>;
+        /**
+         * Send a workspace invitation to a user.
+         *
+         * Creates and dispatches an invitation email. Typical attributes:
+         * `email` (recipient), `workspace_id`, and `role`
+         * (e.g., `"member"`, `"admin"`).
+         *
+         * @param attributes - Invitation attributes. `email` and `workspace_id`
+         *   are required.
+         * @param options - Optional request options.
+         * @returns The newly created `Invitation` record.
+         *
+         * @example
+         * ```typescript
+         * // Using workspace_id shorthand (recommended):
+         * const invite = await client.platform.invitations.create({
+         *   email: 'new.clinician@hospital.org',
+         *   workspace_id: 'ws_abc123',
+         *   role: 'member',
+         * });
+         *
+         * // Using explicit scope_type + scope_id:
+         * const invite2 = await client.platform.invitations.create({
+         *   email: 'admin@hospital.org',
+         *   scope_type: 'tenant',
+         *   scope_id: tenantId,
+         *   role: 'admin',
+         * });
+         * ```
+         */
+        create: (attributes: CreateInvitationAttributes, options?: RequestOptions) => Promise<Invitation>;
+        /**
+         * Resend an invitation email with a refreshed token and new 7-day expiry.
+         *
+         * Only pending invitations can be resent. Generates a new token (invalidating
+         * the old one) and re-sends the invitation email. Callable by the original
+         * inviter or the tenant owner.
+         *
+         * @param id - The UUID of the invitation to resend.
+         * @param options - Optional request options.
+         * @returns The updated `Invitation`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.platform.invitations.resend('inv_abc123');
+         * ```
+         */
+        resend: (id: string, applicationId?: string, options?: RequestOptions) => Promise<Invitation>;
+        /**
+         * List invitations visible to the current actor.
+         *
+         * Returns invitations where the actor is the inviter, the tenant owner,
+         * or the recipient (matched by email). Use this to build admin views
+         * of pending/accepted invitations for a tenant or workspace.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `Invitation` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const invites = await client.platform.invitations.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<Invitation[]>;
+        /**
+         * List all invitations visible to the current actor, auto-paginating.
+         *
+         * @param options - Optional request options.
+         * @returns All visible `Invitation` records as a flat array.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const all = await client.platform.invitations.listAll();
+         * ```
+         */
+        listAll: (options?: RequestOptions) => Promise<Invitation[]>;
+        /**
+         * Look up a pending invitation by its raw token.
+         *
+         * Call this on the `/invite/:token` landing page to display invitation
+         * details before the user accepts. Returns the full invitation record
+         * including `email` (to pre-fill the register form), `role`, `scope_type`,
+         * `scope_id`, `tenant_id`, `expires_at`, and the `inviter` relationship
+         * (pass `include=inviter` via request options to embed inviter email).
+         *
+         * Returns `null` if the token is invalid, already used, or expired —
+         * there is no partial response for consumed tokens.
+         *
+         * **Note:** The response does not include the workspace or tenant name.
+         * Fetch it separately using `platform.workspaces.get(scope_id)` or
+         * `platform.tenants.get(scope_id)` based on `scope_type`.
+         *
+         * @param token - The raw invitation token from the email link (`/invite/:token`).
+         * @param options - Optional request options (e.g., `{ headers: { include: 'inviter' } }`).
+         * @returns The pending `Invitation` record, or `null` if not found.
+         *
+         * @example
+         * ```typescript
+         * // On your /invite/:token page
+         * const invite = await client.platform.invitations.consumeByToken(token);
+         * if (!invite) {
+         *   // Token expired or already used
+         *   return redirect('/invite/expired');
+         * }
+         * // Pre-fill form
+         * setEmail(invite.attributes?.email);
+         * setRole(invite.attributes?.role);
+         * ```
+         */
+        consumeByToken: (token: string, options?: RequestOptions) => Promise<Invitation | null>;
+        /**
+         * Accept a pending invitation using only the raw token.
+         *
+         * Call this after the user is authenticated (either via `registerViaInvitation`
+         * or an existing account login). The platform validates the token, creates or
+         * upgrades the user's `TenantMembership` and `WorkspaceMembership`, and returns
+         * the accepted invitation.
+         *
+         * For new users: `registerViaInvitation` accepts the invitation atomically —
+         * do NOT call `acceptByToken` again after registration. Only call this for
+         * existing users accepting a new invite after sign-in.
+         *
+         * @param token - The raw invitation token from the email link.
+         * @param options - Optional request options.
+         * @returns The accepted `Invitation` with `scope_id` and `tenant_id` populated.
+         *
+         * @example
+         * ```typescript
+         * // Existing user accepting an invite after login
+         * const accepted = await client.platform.invitations.acceptByToken(token);
+         * const workspaceId = accepted.attributes?.scope_type === 'workspace'
+         *   ? accepted.attributes?.scope_id
+         *   : null;
+         * const tenantId = accepted.attributes?.tenant_id;
+         * ```
+         */
+        acceptByToken: (token: string, options?: RequestOptions) => Promise<Invitation>;
+    };
+    /**
+     * Roles — named permission bundles for workspace access control.
+     *
+     * Access via `client.platform.roles`.
+     */
+    roles: {
+        /**
+         * List all roles for the current application.
+         *
+         * @returns Paginated list of roles
+         * @example
+         * const roles = await client.platform.roles.list();
+         */
+        list: () => Promise<{
+            data?: Array<Role>;
+        }>;
+        /**
+         * Create a new role with a set of permissions.
+         *
+         * @param name - Human-readable role name
+         * @param permissions - List of permission strings (e.g. "extract:document:read:all")
+         * @returns The created role
+         * @example
+         * const role = await client.platform.roles.create("Editor", ["extract:document:read:all"]);
+         */
+        create: (name: string, permissions: string[]) => Promise<{
+            data?: Role;
+        }>;
+        /**
+         * Update an existing role.
+         *
+         * @param id - Role UUID
+         * @param attributes - Attributes to update (name, permissions)
+         * @returns The updated role
+         * @example
+         * const updated = await client.platform.roles.update("role-uuid", { name: "Senior Editor" });
+         */
+        update: (id: string, attributes: Partial<{
+            name: string;
+            permissions: string[];
+        }>) => Promise<{
+            data?: Role;
+        }>;
+        /**
+         * Delete a role.
+         *
+         * @param id - Role UUID
+         * @example
+         * await client.platform.roles.destroy("role-uuid");
+         */
+        destroy: (id: string) => Promise<void>;
+    };
+    /**
+     * Permissions — permission registry, presets, and metadata.
+     *
+     * Access via `client.platform.permissions`.
+     */
+    permissions: {
+        /**
+         * List all available permissions for the current application context.
+         *
+         * @param params - Optional filter parameters (context, app, category)
+         * @returns List of permissions
+         * @example
+         * const perms = await client.platform.permissions.list();
+         */
+        list: (params?: Record<string, string>) => Promise<{
+            data?: Array<Permission>;
+        }>;
+        /**
+         * Get a single permission by ID.
+         *
+         * @param id - Permission ID string
+         * @returns The permission record
+         * @example
+         * const perm = await client.platform.permissions.get("extract:document:read:all");
+         */
+        get: (id: string) => Promise<{
+            data?: Permission;
+        }>;
+        /**
+         * Get permission metadata (available contexts, apps, and categories).
+         *
+         * @returns Permission metadata
+         * @example
+         * const meta = await client.platform.permissions.meta();
+         */
+        meta: () => Promise<unknown>;
+        /**
+         * Permission presets — pre-built permission sets per role type.
+         */
+        presets: {
+            /**
+             * List all permission presets, optionally filtered by context or app.
+             *
+             * @param params - Optional filter parameters (context, app)
+             * @returns List of permission presets
+             * @example
+             * const presets = await client.platform.permissions.presets.list({ context: "workspace" });
+             */
+            list: (params?: Record<string, string>) => Promise<{
+                data?: Array<PermissionPreset>;
+            }>;
+            /**
+             * Get a single permission preset by ID.
+             *
+             * @param id - Preset ID string
+             * @returns The permission preset
+             * @example
+             * const preset = await client.platform.permissions.presets.get("workspace_editor");
+             */
+            get: (id: string) => Promise<{
+                data?: PermissionPreset;
+            }>;
+        };
+    };
+    /**
+     * Brand Identities — visual branding configuration for tenants and workspaces.
+     *
+     * Brand identities define the visual appearance (colors, logos, fonts) applied
+     * to tenant or workspace experiences. Each brand identity can be scoped to a
+     * tenant or workspace, and one can be marked as the default at each scope level.
+     *
+     * Access via `client.platform.brandIdentities`.
+     */
+    brandIdentities: {
+        /**
+         * List all brand identities accessible to the current actor.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `BrandIdentity` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brands = await client.platform.brandIdentities.list();
+         * brands.forEach(b => console.log(b.attributes?.name));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<BrandIdentity[]>;
+        /**
+         * Retrieve a single brand identity by its ID.
+         *
+         * @param id - The UUID of the brand identity.
+         * @param options - Optional request options.
+         * @returns The matching `BrandIdentity`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brand = await client.platform.brandIdentities.get('bi_abc123');
+         * console.log(brand.attributes?.name, brand.attributes?.primary_color);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<BrandIdentity>;
+        /**
+         * Create a new brand identity.
+         *
+         * Defines visual branding (colors, logos, fonts) scoped to a tenant or
+         * workspace. Pass `tenant_id` or `workspace_id` to set the scope.
+         *
+         * @param attributes - Brand identity creation attributes. `name` is required.
+         * @param options - Optional request options.
+         * @returns The newly created `BrandIdentity`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brand = await client.platform.brandIdentities.create({
+         *   name: 'Acme Healthcare',
+         *   primary_color: '#2563eb',
+         *   font_family: 'Inter',
+         *   tenant_id: 'tenant_abc123',
+         * });
+         * console.log(brand.id);
+         * ```
+         */
+        create: (attributes: CreateBrandIdentityAttributes, options?: RequestOptions) => Promise<BrandIdentity>;
+        /**
+         * Update a brand identity's attributes.
+         *
+         * @param id - The UUID of the brand identity to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `BrandIdentity`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brand = await client.platform.brandIdentities.update('bi_abc123', {
+         *   primary_color: '#dc2626',
+         *   tagline: 'Caring for you',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateBrandIdentityAttributes, options?: RequestOptions) => Promise<BrandIdentity>;
+        /**
+         * Delete a brand identity.
+         *
+         * Permanently removes the brand identity. Any platform tones associated
+         * with this brand identity should be deleted or reassigned first.
+         *
+         * @param id - The UUID of the brand identity to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.platform.brandIdentities.delete('bi_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List brand identities scoped to a specific tenant.
+         *
+         * @param tenantId - The UUID of the tenant.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `BrandIdentity` records for the tenant.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brands = await client.platform.brandIdentities.listByTenant('tenant_abc123');
+         * ```
+         */
+        listByTenant: (tenantId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<BrandIdentity[]>;
+        /**
+         * List brand identities scoped to a specific workspace.
+         *
+         * @param workspaceId - The UUID of the workspace.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `BrandIdentity` records for the workspace.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brands = await client.platform.brandIdentities.listByWorkspace('ws_abc123');
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<BrandIdentity[]>;
+        /**
+         * Get the default brand identity for a tenant.
+         *
+         * Returns the brand identity marked as default for the given tenant,
+         * or throws if none is set.
+         *
+         * @param tenantId - The UUID of the tenant.
+         * @param options - Optional request options.
+         * @returns The default `BrandIdentity` for the tenant.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const defaultBrand = await client.platform.brandIdentities.getDefaultForTenant('tenant_abc123');
+         * console.log(defaultBrand.attributes?.name);
+         * ```
+         */
+        getDefaultForTenant: (tenantId: string, options?: RequestOptions) => Promise<BrandIdentity>;
+        /**
+         * Get the default brand identity for a workspace.
+         *
+         * Returns the brand identity marked as default for the given workspace,
+         * or throws if none is set.
+         *
+         * @param workspaceId - The UUID of the workspace.
+         * @param options - Optional request options.
+         * @returns The default `BrandIdentity` for the workspace.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const defaultBrand = await client.platform.brandIdentities.getDefaultForWorkspace('ws_abc123');
+         * console.log(defaultBrand.attributes?.name);
+         * ```
+         */
+        getDefaultForWorkspace: (workspaceId: string, options?: RequestOptions) => Promise<BrandIdentity>;
+        /**
+         * Mark a brand identity as the default for its scope (tenant or workspace).
+         *
+         * If another brand identity was previously the default at this scope,
+         * it is automatically unset.
+         *
+         * @param id - The UUID of the brand identity to set as default.
+         * @param options - Optional request options.
+         * @returns The updated `BrandIdentity` with `is_default` set to `true`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brand = await client.platform.brandIdentities.setDefault('bi_abc123');
+         * console.log(brand.attributes?.is_default); // true
+         * ```
+         */
+        setDefault: (id: string, options?: RequestOptions) => Promise<BrandIdentity>;
+        /**
+         * Remove the default status from a brand identity.
+         *
+         * After this call, the scope (tenant or workspace) will have no default
+         * brand identity until another is explicitly set.
+         *
+         * @param id - The UUID of the brand identity to unset as default.
+         * @param options - Optional request options.
+         * @returns The updated `BrandIdentity` with `is_default` set to `false`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const brand = await client.platform.brandIdentities.unsetDefault('bi_abc123');
+         * console.log(brand.attributes?.is_default); // false
+         * ```
+         */
+        unsetDefault: (id: string, options?: RequestOptions) => Promise<BrandIdentity>;
+    };
+    /**
+     * Platform Tones — communication tone and style configuration.
+     *
+     * Platform tones define the voice, formality, and vocabulary preferences
+     * used by AI-generated content within a brand identity context. Each tone
+     * is associated with a brand identity and can be used to customize how
+     * the platform communicates on behalf of the brand.
+     *
+     * Access via `client.platform.platformTones`.
+     */
+    platformTones: {
+        /**
+         * List all platform tones accessible to the current actor.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `PlatformTone` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tones = await client.platform.platformTones.list();
+         * tones.forEach(t => console.log(t.attributes?.name));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<PlatformTone[]>;
+        /**
+         * Retrieve a single platform tone by its ID.
+         *
+         * @param id - The UUID of the platform tone.
+         * @param options - Optional request options.
+         * @returns The matching `PlatformTone`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tone = await client.platform.platformTones.get('pt_abc123');
+         * console.log(tone.attributes?.name, tone.attributes?.formality_level);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<PlatformTone>;
+        /**
+         * Create a new platform tone.
+         *
+         * Defines tone and style preferences for AI-generated content within
+         * the context of a brand identity. `brand_identity_id` is required to
+         * associate the tone with the correct brand.
+         *
+         * @param attributes - Platform tone creation attributes. `name` and `brand_identity_id` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `PlatformTone`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tone = await client.platform.platformTones.create({
+         *   name: 'Professional',
+         *   brand_identity_id: 'bi_abc123',
+         *   formality_level: 'formal',
+         *   tone_style: 'authoritative',
+         * });
+         * console.log(tone.id);
+         * ```
+         */
+        create: (attributes: CreatePlatformToneAttributes, options?: RequestOptions) => Promise<PlatformTone>;
+        /**
+         * Update a platform tone's attributes.
+         *
+         * @param id - The UUID of the platform tone to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `PlatformTone`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tone = await client.platform.platformTones.update('pt_abc123', {
+         *   formality_level: 'casual',
+         *   tone_style: 'friendly',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdatePlatformToneAttributes, options?: RequestOptions) => Promise<PlatformTone>;
+        /**
+         * Delete a platform tone.
+         *
+         * Permanently removes the platform tone.
+         *
+         * @param id - The UUID of the platform tone to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.platform.platformTones.delete('pt_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * List platform tones associated with a specific brand identity.
+         *
+         * @param brandIdentityId - The UUID of the brand identity.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `PlatformTone` records for the brand.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const tones = await client.platform.platformTones.listByBrand('bi_abc123');
+         * tones.forEach(t => console.log(t.attributes?.name));
+         * ```
+         */
+        listByBrand: (brandIdentityId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<PlatformTone[]>;
+    };
+};
+//# sourceMappingURL=platform.d.ts.map