@gpt-platform/client 0.10.5 → 0.11.0

package/dist/gpt-client.d.ts

@@ -0,0 +1,2175 @@
+import { BaseClient, BaseClientConfig } from "./base-client";
+import { createClinicalNamespace } from "./namespaces/clinical";
+import type { SdkEvents } from "./events";
+/**
+ * GPT Core Client SDK
+ *
+ * The main entry point for interacting with the GPT Core API.
+ * Provides a namespaced, type-safe interface for all API operations.
+ *
+ * @example
+ * ```typescript
+ * import { GptClient } from '@gpt-platform/client';
+ *
+ * const client = new GptClient({
+ *   baseUrl: 'https://api.gpt-core.com',
+ *   apiKey: 'sk_app_...',
+ * });
+ *
+ * // Authentication
+ * const user = await client.identity.me();
+ *
+ * // Workspaces
+ * const workspaces = await client.platform.workspaces.mine();
+ *
+ * // AI Search
+ * const results = await client.ai.search('quarterly earnings');
+ *
+ * // Documents
+ * const docs = await client.extraction.documents.list();
+ * ```
+ */
+export declare class GptClient extends BaseClient {
+    /** Audit log activity feed — read-only tenant activity feed scoped to the authenticated tenant */
+    readonly audit: {
+        activityFeed(params: import("./namespaces/audit").ActivityFeedParams, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/audit").AuditLog[]>;
+    };
+    /** Agent creation, versioning, training, and testing */
+    readonly agents: {
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & import("./base-client").RequestOptions) => Promise<import(".").Agent[]>;
+        listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").Agent[]>;
+        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        getBySlug: (slug: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        create: (name: string, attributes?: import("./namespaces/agents").CreateAgentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        update: (id: string, attributes: import("./namespaces/agents").UpdateAgentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        test: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        validate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        clone: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        export: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        analyzeTraining: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        teach: (id: string, params?: import("./namespaces/agents").TeachParams, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        publishVersion: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        restoreVersion: (id: string, body?: {
+            version_id?: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        stats: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").AgentStatsResponse>;
+        import: (data: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        usage: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").AgentUsageResponse>;
+        usageAll: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").AgentUsageResponse[]>;
+        getOrCreateDraft: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+        publishDraft: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+        cloneForWorkspace: (agentId: string, targetWorkspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
+        trainingStats: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").TrainingStatsResponse>;
+        createTestResult: (attributes: import("./namespaces/agents").CreateTestResultAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").AgentTestResultResponse>;
+        versions: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").AgentVersion[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            create: (attributes: import("./namespaces/agents").CreateAgentVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+            addSystemField: (id: string, fieldName: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+            removeSystemField: (id: string, fieldName: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+            setSystemFields: (id: string, fieldNames: string[], options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+            metrics: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").VersionMetricsResponse>;
+            revisions: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").VersionRevision[]>;
+            getRevision: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").VersionRevision>;
+            listAllRevisions: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").VersionRevision[]>;
+            compare: (versionAId: string, versionBId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").VersionComparisonResponse>;
+            schemaVersions: {
+                list: (agentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion[]>;
+                create: (agentId: string, attributes: import("./namespaces/agents").CreateAgentVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+                activate: (agentId: string, versionId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+                update: (agentId: string, versionId: string, attributes: import("./namespaces/agents").UpdateAgentVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
+            };
+        };
+        training: {
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            create: (attributes: import("./namespaces/agents").CreateAgentTrainingExampleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            update: (id: string, attributes: import("./namespaces/agents").UpdateAgentTrainingExampleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            bulkCreate: (examples: import("./namespaces/agents").CreateAgentTrainingExampleAttributes[], options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample[]>;
+            bulkDelete: (ids: string[], options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").BulkDeleteResponse>;
+            search: (query: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample[]>;
+            listForAgent: (agentId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample[]>;
+            deleteForAgent: (agentId: string, exampleId: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            sessions: {
+                list: (agentId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingSession[]>;
+                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingSession>;
+                delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            };
+        };
+        fieldTemplates: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").FieldTemplate[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").FieldTemplate>;
+            create: (attributes: import("./namespaces/agents").CreateFieldTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").FieldTemplate>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        executions: {
+            start: (agentId: string, input: Record<string, unknown>, opts?: {
+                workspace_id?: string;
+                model_id?: string;
+            } & import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").Execution>;
+            estimate: (agentId: string, input: Record<string, unknown>, opts?: {
+                workspace_id?: string;
+            } & import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").ExecutionEstimateResponse>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").Execution>;
+            list: (opts?: {
+                workspace_id?: string;
+            } & import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").Execution[]>;
+            stream: (id: string, options?: import("./base-client").RequestOptions & import("./streaming").StreamOptions) => Promise<AsyncIterableIterator<import("./execution-events").ExecutionEvent>>;
+            approve: (id: string, approvedData?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").Execution>;
+            deny: (id: string, reason: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").Execution>;
+            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").Execution>;
+            children: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").Execution[]>;
+            tree: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").ExecutionTreeResponse>;
+        };
+        deployments: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").AgentDeployment[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentDeployment>;
+        };
+        workspaceConfigs: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").WorkspaceAgentConfig[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WorkspaceAgentConfig>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").WorkspaceAgentConfig>;
+        };
+    };
+    /** Semantic search, embeddings, and AI conversations */
+    readonly ai: {
+        search: (query: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").AiSearchResponse>;
+        searchAdvanced: (query: string, params?: import("./namespaces/ai").AiSearchAdvancedParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").AiSearchResponse>;
+        embed: (text: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").AiEmbedResponse>;
+        conversations: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").AiConversation[]>;
+            create: (attributes?: import("./namespaces/ai").CreateAiConversationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").AiConversation>;
+        };
+        messages: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").AiMessage[]>;
+            send: (conversationId: string, body: import("./namespaces/ai").AiMessageBody, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").AiMessage>;
+        };
+        graph: {
+            listNodes: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").GraphNode[]>;
+            createNode: (attributes: import("./namespaces/ai").CreateGraphNodeAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").GraphNode>;
+            deleteNode: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+    };
+    /** Wallet, plans, transactions, and payment methods */
+    readonly billing: {
+        wallet: {
+            get: (options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            previewPlanChange: (planSlug: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            changePlan: (walletIdOrSlug: string, planSlugOrOptions?: string | import("./base-client").RequestOptions, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            buyCredits: (walletId: string, packageSlug: string, paymentMethodId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            updateAutoTopUp: (walletId: string, opts: {
+                enabled: boolean;
+                threshold?: number;
+                amount?: number;
+                packageId?: string;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            invoices: {
+                list: (options?: {
+                    page?: number;
+                    pageSize?: number;
+                } & import("./base-client").RequestOptions) => Promise<import(".").Invoice[]>;
+                listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").Invoice[]>;
+            };
+            buyAddon: (addonSlug: string, paymentMethodId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            cancelAddon: (addonSlug: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            cancelPlan: (immediateOrOptions?: boolean | import("./base-client").RequestOptions, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+            retryPayment: (options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
+        };
+        seats: {
+            get: (options?: import("./base-client").RequestOptions) => Promise<import(".").SeatInfo>;
+        };
+        plans: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Plan[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").Plan[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Plan>;
+        };
+        transactions: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Transaction[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").Transaction[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Transaction>;
+        };
+        creditPackages: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CreditPackage[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").CreditPackage[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CreditPackage>;
+        };
+        paymentMethods: {
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").PaymentMethod[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").PaymentMethod[]>;
+            create: (attributes: import("./namespaces/billing").PaymentMethodCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PaymentMethod>;
+            tokenize: (cardDetails: import("./namespaces/billing").PaymentMethodTokenizeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PaymentMethod>;
+            update: (id: string, attributes: import("./namespaces/billing").PaymentMethodUpdateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PaymentMethod>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PaymentMethod>;
+            setDefault: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PaymentMethod>;
+        };
+        featureDefinitions: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition>;
+            listByApplication: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition[]>;
+            create: (attrs: {
+                key: string;
+                name: string;
+                metering_mode: "unlimited" | "counted" | "credit_cost";
+                default_limit?: number;
+                credit_cost?: number;
+                platform_capability?: string;
+                metadata?: Record<string, unknown>;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition>;
+            update: (id: string, attrs: import("./namespaces/billing").UpdateFeatureDefinitionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
+        };
+        featureUsages: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureUsage[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureUsage>;
+            listByTenant: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureUsage[]>;
+            increment: (featureKey: string, options?: import("./base-client").RequestOptions) => Promise<{
+                used: number;
+                remaining: number | null;
+            }>;
+        };
+        planFeatureAllocations: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation>;
+            listByPlan: (planId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation[]>;
+        };
+        featureSummary: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureSummary[]>;
+        };
+        capacityCalculator: (planSlug: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").CapacityCalculatorResponse>;
+    };
+    /** Product catalog, inventory, pricing, and taxonomy */
+    readonly catalog: {
+        products: {
+            list: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogProduct[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogProduct>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogProductAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogProduct>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogProductAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogProduct>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        variants: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogProductVariant>;
+            listByProduct: (productId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogProductVariant[]>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogProductVariantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogProductVariant>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogProductVariantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogProductVariant>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        optionTypes: {
+            listByApplication: (applicationId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionType[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionType>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogOptionTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionType>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogOptionTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionType>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        optionValues: {
+            listByOptionType: (optionTypeId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionValue[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionValue>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogOptionValueAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionValue>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogOptionValueAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogOptionValue>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        taxonomies: {
+            listByApplication: (applicationId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomy[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomy>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogTaxonomyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomy>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogTaxonomyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomy>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        taxonomyNodes: {
+            listByTaxonomy: (taxonomyId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomyNode[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomyNode>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogTaxonomyNodeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomyNode>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogTaxonomyNodeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogTaxonomyNode>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        views: {
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogView[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogView>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogViewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogView>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogViewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogView>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        priceLists: {
+            listByApplication: (applicationId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogPriceList[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogPriceList>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogPriceListAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogPriceList>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogPriceListAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogPriceList>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        priceListEntries: {
+            listByPriceList: (priceListId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").CatalogPriceListEntry[]>;
+            create: (attributes: import("./namespaces/catalog").CreateCatalogPriceListEntryAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogPriceListEntry>;
+            update: (id: string, attributes: import("./namespaces/catalog").UpdateCatalogPriceListEntryAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CatalogPriceListEntry>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+    };
+    /** Patient management, sessions, notes, health metrics, and care plans */
+    readonly clinical: ReturnType<typeof createClinicalNamespace>;
+    /** HIPAA/GDPR compliance — audit logs, breach incidents, consent, DPIA, data subject requests */
+    readonly compliance: {
+        auditLogs: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").AuditLog[]>;
+        };
+        auditChain: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").AuditChainEntry[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AuditChainEntry>;
+        };
+        breachIncidents: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").BreachIncident[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachIncident>;
+            create: (attributes: import("./namespaces/compliance").CreateBreachIncidentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachIncident>;
+            updateStatus: (id: string, status: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachIncident>;
+        };
+        breachNotifications: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").BreachNotification[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachNotification>;
+        };
+        consentRecords: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ConsentRecord[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConsentRecord>;
+            listActive: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConsentRecord[]>;
+            create: (attributes: import("./namespaces/compliance").CreateConsentRecordAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConsentRecord>;
+            withdraw: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConsentRecord>;
+        };
+        impactAssessments: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").DataProtectionImpactAssessment[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataProtectionImpactAssessment>;
+            create: (attributes: import("./namespaces/compliance").CreateImpactAssessmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataProtectionImpactAssessment>;
+            update: (id: string, attributes: import("./namespaces/compliance").UpdateImpactAssessmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataProtectionImpactAssessment>;
+            approve: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataProtectionImpactAssessment>;
+        };
+        processingActivities: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ProcessingActivity[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ProcessingActivity>;
+            create: (attributes: import("./namespaces/compliance").CreateProcessingActivityAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ProcessingActivity>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        retentionPolicies: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").RetentionPolicy[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").RetentionPolicy>;
+            create: (attributes: import("./namespaces/compliance").CreateRetentionPolicyAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").RetentionPolicy>;
+            update: (id: string, attributes: import("./namespaces/compliance").UpdateRetentionPolicyAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").RetentionPolicy>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        dataSubjectRequests: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").DataSubjectRequest[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataSubjectRequest>;
+            create: (attributes: import("./namespaces/compliance").CreateDataSubjectRequestAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataSubjectRequest>;
+            updateStatus: (id: string, status: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataSubjectRequest>;
+        };
+        legalDocuments: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument>;
+            create: (attributes: import("./namespaces/compliance").CreateLegalDocumentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument>;
+            update: (id: string, attributes: import("./namespaces/compliance").UpdateLegalDocumentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            byLocale: (locale: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument[]>;
+            forApplication: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument[]>;
+            publish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument>;
+            unpublish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalDocument>;
+        };
+        legalAcceptances: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").LegalAcceptance[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalAcceptance>;
+            latest: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").LegalAcceptance>;
+        };
+        scanResults: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ScanResult[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ScanResult>;
+        };
+        getPosture: (params: {
+            workspace_id: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/compliance").CompliancePosture>;
+        riskAssessments: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").RiskAssessment[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").RiskAssessment>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").RiskAssessment>;
+            updateStatus: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").RiskAssessment>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        dataTransferRecords: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").DataTransferRecord[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataTransferRecord>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataTransferRecord>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        cdeScopeReports: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CdeScopeReport[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CdeScopeReport>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CdeScopeReport>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        accessLogs: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").AccessLog[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AccessLog>;
+        };
+        disclosureLogs: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").DisclosureLog[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DisclosureLog>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DisclosureLog>;
+            listBySubject: (options?: {
+                filter?: Record<string, unknown>;
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").DisclosureLog[]>;
+        };
+        amendmentRequests: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").AmendmentRequest[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AmendmentRequest>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AmendmentRequest>;
+            review: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AmendmentRequest>;
+            approve: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AmendmentRequest>;
+            deny: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AmendmentRequest>;
+            apply: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").AmendmentRequest>;
+        };
+        complianceDocumentTemplates: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceDocumentTemplate[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceDocumentTemplate>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceDocumentTemplate>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceDocumentTemplate>;
+            clone: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceDocumentTemplate>;
+        };
+        businessAssociateAgreements: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").BusinessAssociateAgreement[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BusinessAssociateAgreement>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BusinessAssociateAgreement>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BusinessAssociateAgreement>;
+            sign: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BusinessAssociateAgreement>;
+            terminate: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BusinessAssociateAgreement>;
+        };
+        policyReviewSchedules: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").PolicyReviewSchedule[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PolicyReviewSchedule>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PolicyReviewSchedule>;
+            completeReview: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PolicyReviewSchedule>;
+            markDue: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PolicyReviewSchedule>;
+            markOverdue: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PolicyReviewSchedule>;
+        };
+        complianceRequirements: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceRequirement[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceRequirement>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceRequirement>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceRequirement>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        complianceRequirementCompletions: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceRequirementCompletion[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceRequirementCompletion>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceRequirementCompletion>;
+        };
+        complianceOfficerDesignations: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceOfficerDesignation[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceOfficerDesignation>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceOfficerDesignation>;
+            revoke: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ComplianceOfficerDesignation>;
+        };
+        ephiAssets: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EphiAsset[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EphiAsset>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EphiAsset>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EphiAsset>;
+        };
+        ephiDataFlows: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EphiDataFlow[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EphiDataFlow>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EphiDataFlow>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EphiDataFlow>;
+        };
+        breachNotificationArtifacts: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").BreachNotificationArtifact[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachNotificationArtifact>;
+            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachNotificationArtifact>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachNotificationArtifact>;
+            send: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BreachNotificationArtifact>;
+        };
+    };
+    /** Notification logs, methods, and preferences */
+    readonly communication: {
+        notifications: {
+            logs: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationLog[]>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationLog[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationLog[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationLog>;
+            methods: {
+                delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+                list: (options?: {
+                    page?: number;
+                    pageSize?: number;
+                } & import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationMethod[]>;
+                listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationMethod[]>;
+                create: (attributes: import("./namespaces/communication").CreateNotificationMethodAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationMethod>;
+                update: (id: string, attributes: import("./namespaces/communication").UpdateNotificationMethodAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationMethod>;
+                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationMethod>;
+            };
+            preferences: {
+                delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+                list: (options?: {
+                    page?: number;
+                    pageSize?: number;
+                } & import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationPreference[]>;
+                listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationPreference[]>;
+                create: (attributes: import("./namespaces/communication").CreateNotificationPreferenceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationPreference>;
+                update: (id: string, attributes: import("./namespaces/communication").UpdateNotificationPreferenceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationPreference>;
+                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").NotificationPreference>;
+            };
+        };
+    };
+    /** OAuth and API adapters for external systems */
+    readonly connectors: {
+        instances: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConnectorInstance[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConnectorInstance>;
+            create: (attributes: import("./namespaces/connectors").CreateConnectorInstanceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConnectorInstance>;
+            update: (id: string, attributes: import("./namespaces/connectors").UpdateConnectorInstanceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConnectorInstance>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        credentials: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Credential[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Credential>;
+            refresh: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Credential>;
+            upsert: (attributes: import("./namespaces/connectors").UpsertCredentialAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Credential>;
+            deleteByType: (workspaceId: string, connectorType: string, scopeLevel: string, options?: import("./base-client").RequestOptions) => Promise<{
+                deleted: boolean;
+            }>;
+        };
+        oauth: {
+            connect: (connectorType: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").OAuthInitiateResult>;
+            callback: (connectorType: string, code: string, state: string, workspaceId: string, redirectUri?: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConnectorInstance>;
+        };
+        available: {
+            list: () => string[];
+        };
+        sync: {
+            trigger: (connectorInstanceId: string, params: import("./namespaces/connectors").TriggerSyncParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").SyncTriggerResult>;
+            logs: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").SyncLog[]>;
+            log: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").SyncLog>;
+        };
+        edamam: {
+            recipes: {
+                search: (connectorInstanceId: string, workspaceId: string, params: import("./namespaces/connectors").EdamamSearchParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").EdamamSearchResult>;
+                get: (connectorInstanceId: string, workspaceId: string, recipeId: string, options?: import("./base-client").RequestOptions) => Promise<{
+                    recipe: import("./namespaces/connectors").EdamamRecipe;
+                }>;
+            };
+        };
+        fullscript: {
+            checkPatient: (connectorId: string, workspaceId: string, email: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptPatient | null>;
+            createPatient: (connectorId: string, workspaceId: string, attrs: {
+                first_name: string;
+                last_name: string;
+                email: string;
+                date_of_birth?: string;
+            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptPatient>;
+            sessionGrant: (connectorId: string, workspaceId: string, patientId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptSessionGrant>;
+            listTreatmentPlans: (connectorId: string, workspaceId: string, patientId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptTreatmentPlan[]>;
+            getTreatmentPlan: (connectorId: string, workspaceId: string, treatmentPlanId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptTreatmentPlan>;
+            cancelTreatmentPlan: (connectorId: string, workspaceId: string, treatmentPlanId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptTreatmentPlan>;
+            createTreatmentPlan: (connectorId: string, workspaceId: string, attrs: import("./namespaces/connectors").CreateTreatmentPlanAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptTreatmentPlan>;
+            matchProducts: (connectorId: string, workspaceId: string, queries: import("./namespaces/connectors").ProductMatchQuery[], options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ProductMatchResult[]>;
+            searchProducts: (connectorId: string, workspaceId: string, query: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptProduct[]>;
+            getProduct: (connectorId: string, workspaceId: string, productId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptProduct>;
+            listSimilarProducts: (connectorId: string, workspaceId: string, productId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptProduct[]>;
+            listPatientOrders: (connectorId: string, workspaceId: string, patientId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptOrder[]>;
+            getOrder: (connectorId: string, workspaceId: string, orderId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").FullscriptOrder>;
+            oauth: {
+                connect: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").OAuthInitiateResult>;
+                callback: (code: string, state: string, workspaceId: string, redirectUri?: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ConnectorInstance>;
+            };
+        };
+        practiceBetter: {
+            pushNote: (connectorInstanceId: string, params: import("./namespaces/connectors").PBPushNoteParams, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+        };
+        healthie: {
+            listPatients: (connectorId: string, workspaceId: string, options?: import("./namespaces/connectors").HealthieListOptions & import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").HealthiePatient[]>;
+            syncPatients: (connectorId: string, workspaceId: string, requestOptions?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").HealthieSyncResult>;
+            listAppointments: (connectorId: string, workspaceId: string, options?: import("./namespaces/connectors").HealthieListOptions & import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").HealthieAppointment[]>;
+            syncAppointments: (connectorId: string, workspaceId: string, requestOptions?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").HealthieSyncResult>;
+            syncAll: (connectorId: string, workspaceId: string, requestOptions?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").HealthieSyncAllResult>;
+            getStatus: (connectorId: string, workspaceId: string, requestOptions?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").HealthieSyncStatus>;
+        };
+    };
+    /** Web crawling and content extraction */
+    readonly crawler: {
+        jobs: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerJob[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerJob>;
+            create: (attributes: import("./namespaces/crawler").CreateCrawlerJobAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerJob>;
+            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerJob>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        schedules: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerSchedule[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerSchedule>;
+            create: (attributes: import("./namespaces/crawler").CreateCrawlerScheduleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerSchedule>;
+            update: (id: string, attributes: import("./namespaces/crawler").UpdateCrawlerScheduleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerSchedule>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            enable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerSchedule>;
+            disable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerSchedule>;
+            trigger: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerSchedule>;
+        };
+        results: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerResult[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrawlerResult>;
+        };
+    };
+    /** Contacts, companies, deals, activities, pipelines, relationships, and custom entities */
+    readonly crm: {
+        contacts: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmContact>;
+            create: (attributes: import("./namespaces/crm").CreateCrmContactAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmContact>;
+            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmContactAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmContact>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: {
+                name?: string;
+                status?: "lead" | "marketing_qualified" | "sales_qualified" | "opportunity" | "customer" | "evangelist" | "churned";
+                filters?: import("./namespaces/crm").AttributeFilter[];
+                tags?: string[];
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrmContact[]>;
+            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmContact>;
+            unarchive: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmContact>;
+            listArchived: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrmContact[]>;
+        };
+        companies: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCompany>;
+            create: (attributes: import("./namespaces/crm").CreateCrmCompanyAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCompany>;
+            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmCompanyAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCompany>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCompany[]>;
+        };
+        deals: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmDeal>;
+            create: (attributes: import("./namespaces/crm").CreateCrmDealAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmDeal>;
+            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmDealAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmDeal>;
+            moveStage: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmDeal>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrmDeal[]>;
+        };
+        activities: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmActivity>;
+            create: (attributes: import("./namespaces/crm").CreateCrmActivityAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmActivity>;
+            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmActivity>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrmActivity[]>;
+        };
+        pipelines: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipeline>;
+            create: (attributes: import("./namespaces/crm").CreateCrmPipelineAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipeline>;
+            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmPipelineAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipeline>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipeline[]>;
+        };
+        pipelineStages: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipelineStage>;
+            create: (attributes: import("./namespaces/crm").CreateCrmPipelineStageAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipelineStage>;
+            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmPipelineStageAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipelineStage>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByPipeline: (pipelineId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmPipelineStage[]>;
+        };
+        relationshipTypes: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmRelationshipType>;
+            create: (attributes: import("./namespaces/crm").CreateCrmRelationshipTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmRelationshipType>;
+            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmRelationshipTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmRelationshipType>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmRelationshipType[]>;
+        };
+        relationships: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmRelationship>;
+            create: (attributes: import("./namespaces/crm").CreateCrmRelationshipAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmRelationship>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmRelationship[]>;
+        };
+        customEntities: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCustomEntity>;
+            create: (attributes: import("./namespaces/crm").CreateCrmCustomEntityAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCustomEntity>;
+            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmCustomEntityAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCustomEntity>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: {
+                type?: string;
+                filters?: import("./namespaces/crm").AttributeFilter[];
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCustomEntity[]>;
+            batchUpdate: (workspaceId: string, updates: Array<{
+                id: string;
+                attributes: import("./namespaces/crm").UpdateCrmCustomEntityAttributes;
+            }>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCustomEntity[]>;
+            aggregate: (workspaceId: string, params: {
+                type?: string;
+                metrics: Array<import("./namespaces/crm").AggregateMetric | import("./namespaces/crm").AggregateFieldMetric>;
+                group_by?: string;
+                filters?: import("./namespaces/crm").AttributeFilter[];
+            }, options?: import("./base-client").RequestOptions) => Promise<Array<Record<string, unknown>>>;
+            versions: {
+                list: (entityId: string, options?: {
+                    page?: number;
+                    pageSize?: number;
+                } & import("./base-client").RequestOptions) => Promise<{
+                    data: import("./namespaces/crm").CrmCustomEntityVersion[];
+                    meta?: unknown;
+                }>;
+                get: (entityId: string, versionId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/crm").CrmCustomEntityVersion>;
+                restore: (entityId: string, versionId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").CrmCustomEntity>;
+            };
+        };
+        export: {
+            create: (workspaceId: string, params: import("./namespaces/crm").CrmExportCreateParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/crm").CrmDataExportJob>;
+            get: (jobId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/crm").CrmDataExportJob>;
+            list: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/crm").CrmDataExportJob[]>;
+            refreshUrl: (jobId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/crm").CrmDataExportJob>;
+        };
+    };
+    /** AI content generation — text, images, tone rewriting, hashtags, SEO */
+    readonly content: {
+        generateText: (attributes: {
+            prompt: string;
+            workspace_id: string;
+            brand_identity_id?: string;
+            task?: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        generateImage: (attributes: {
+            prompt: string;
+            workspace_id: string;
+            style?: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        editImage: (attributes: {
+            image_url: string;
+            instructions: string;
+            workspace_id: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        rewriteTone: (attributes: {
+            text: string;
+            target_tone: string;
+            workspace_id: string;
+            max_length?: number;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        shorten: (attributes: {
+            text: string;
+            max_chars: number;
+            workspace_id: string;
+            platform?: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        refine: (attributes: {
+            text: string;
+            instructions: string;
+            workspace_id: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        suggestTopics: (attributes: {
+            workspace_id: string;
+            industry?: string;
+            brand_identity_id?: string;
+            count?: number;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        generateImagePrompt: (attributes: {
+            marketing_copy: string;
+            workspace_id: string;
+            style?: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        generateHashtags: (attributes: {
+            text: string;
+            platform: string;
+            workspace_id: string;
+            industry?: string;
+            count?: number;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        seoEnrich: (attributes: {
+            text: string;
+            target_keywords: string[];
+            workspace_id: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+    };
+    /** Email campaigns, recipients, AI generation, and sequences */
+    readonly campaigns: {
+        campaigns: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Campaign>;
+            create: (attributes: import("./namespaces/campaigns").CreateCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Campaign>;
+            update: (id: string, attributes: import("./namespaces/campaigns").UpdateCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Campaign>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").Campaign[]>;
+            send: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Campaign>;
+            analyze: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/campaigns").CampaignAnalysisResult>;
+            optimizeSendTimes: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Campaign>;
+            createFollowup: (id: string, attributes: import("./namespaces/campaigns").CreateFollowupCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Campaign>;
+            importRecipients: (id: string, attributes: import("./namespaces/campaigns").ImportRecipientsAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+            generateEmails: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+            optimizeSubjects: (id: string, attributes: import("./namespaces/campaigns").OptimizeSubjectsAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+            export: (id: string, attributes: import("./namespaces/campaigns").ExportCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+        };
+        templates: {
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingTemplate[]>;
+            compile: (mjml: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/email").MjmlCompileResult>;
+            preview: (templateId: string, variables: Record<string, string>, options?: import("./base-client").RequestOptions) => Promise<{
+                preview_html: string;
+            }>;
+            publish: (templateId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingTemplate>;
+            unpublish: (templateId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingTemplate>;
+            rollback: (templateId: string, versionNumber: number, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingTemplate>;
+            versions: (templateId: string, options?: import("./base-client").RequestOptions) => Promise<Omit<import("./namespaces/email").TemplateVersion, "body_html" | "body_mjml">[]>;
+            getVersion: (templateId: string, versionNumber: number, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/email").TemplateVersion>;
+        };
+        generatedEmails: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingGeneratedEmail>;
+            update: (id: string, attributes: import("./namespaces/campaigns").UpdateGeneratedEmailAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingGeneratedEmail>;
+            approve: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingGeneratedEmail>;
+            reject: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingGeneratedEmail>;
+            schedule: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingGeneratedEmail>;
+            listByCampaign: (campaignId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingGeneratedEmail[]>;
+        };
+        senderProfiles: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            update: (id: string, attributes: import("./namespaces/campaigns").UpdateSenderProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            validateDns: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        sequences: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence>;
+            create: (attributes: import("./namespaces/campaigns").CreateSequenceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence>;
+            update: (id: string, attributes: import("./namespaces/campaigns").UpdateSequenceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            activate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence>;
+            pause: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence>;
+            complete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence[]>;
+            resume: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSequence>;
+        };
+        recipients: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+            listByCampaign: (campaignId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<Record<string, unknown>[]>;
+        };
+        sequenceSteps: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+            create: (attributes: import("./namespaces/campaigns").CreateSequenceStepAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
+            listBySequence: (sequenceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<Record<string, unknown>[]>;
+        };
+    };
+    /** Direct email composition, AI drafting, sender profiles, and tracking */
+    readonly email: {
+        outboundEmails: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail>;
+            create: (attributes: import("./namespaces/email").CreateOutboundEmailAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail>;
+            composeWithAi: (attributes: import("./namespaces/email").ComposeWithAiAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail>;
+            update: (id: string, attributes: import("./namespaces/email").UpdateOutboundEmailAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            send: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail>;
+            schedule: (id: string, attributes: {
+                scheduled_for: string;
+            }, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail>;
+            cancelSchedule: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail[]>;
+            listByContact: (workspaceId: string, contactRefId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailOutboundEmail[]>;
+        };
+        senderProfiles: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            create: (attributes: import("./namespaces/email").CreateEmailSenderProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            update: (id: string, attributes: import("./namespaces/email").UpdateEmailSenderProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            validateDns: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            setDefault: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailMarketingSenderProfile[]>;
+        };
+        recipients: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailRecipient>;
+            create: (attributes: {
+                outbound_email_id: string;
+                email: string;
+                name?: string;
+                recipient_type?: "to" | "cc" | "bcc";
+            }, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailRecipient>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByEmail: (outboundEmailId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailRecipient[]>;
+        };
+        inclusions: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInclusion>;
+            create: (attributes: {
+                outbound_email_id: string;
+                inclusion_type: "goal" | "metric" | "chart" | "resource" | "supplement" | "custom";
+                ref_id?: string;
+                title?: string;
+                data?: Record<string, unknown>;
+                position?: number;
+            }, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInclusion>;
+            update: (id: string, attributes: {
+                title?: string;
+                rendered_html?: string;
+                data?: Record<string, unknown>;
+                position?: number;
+            }, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInclusion>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByEmail: (outboundEmailId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInclusion[]>;
+        };
+        trackingEvents: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailTrackingEvent>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailTrackingEvent[]>;
+        };
+        unsubscribers: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailUnsubscriber>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailUnsubscriber[]>;
+        };
+        sendLimits: {
+            get: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/email").EmailSendLimit>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./namespaces/email").EmailSendLimit[]>;
+        };
+        inbound: {
+            addresses: {
+                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundAddress>;
+                create: (attributes: {
+                    workspace_id: string;
+                    name: string;
+                    routing_target: "extraction" | "agent" | "invoices" | "crm";
+                    handler_config?: Record<string, unknown>;
+                    max_attachment_size_mb?: number;
+                    allowed_mime_types?: string[] | null;
+                    daily_receive_limit?: number;
+                }, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundAddress>;
+                update: (id: string, attributes: import("./namespaces/email").UpdateInboundAddressAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundAddress>;
+                delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+                rotateToken: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundAddress>;
+                disable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundAddress>;
+                enable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundAddress>;
+                listByWorkspace: (workspaceId: string, options?: {
+                    page?: number;
+                    pageSize?: number;
+                } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundAddress[]>;
+            };
+            received: {
+                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundEmail>;
+                listByAddress: (addressId: string, options?: {
+                    page?: number;
+                    pageSize?: number;
+                } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundEmail[]>;
+                listByWorkspace: (workspaceId: string, options?: {
+                    page?: number;
+                    pageSize?: number;
+                } & import("./base-client").RequestOptions) => Promise<import("./_internal").EmailInboundEmail[]>;
+            };
+        };
+    };
+    /** Support tickets, tags, and SLA tracking */
+    readonly support: {
+        tickets: {
+            list: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            create: (attributes: import("./namespaces/support").CreateSupportTicketAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            update: (id: string, attributes: import("./namespaces/support").UpdateSupportTicketAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            assign: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            resolve: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            close: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            reopen: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            merge: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicket>;
+            addMessage: (ticketId: string, attributes: import("./namespaces/support").CreateTicketMessageAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicketMessage>;
+            listMessages: (ticketId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicketMessage[]>;
+            rate: (attributes: import("./namespaces/support").CreateTicketRatingAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTicketRating>;
+        };
+        tags: {
+            list: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTag[]>;
+            create: (attributes: import("./namespaces/support").CreateSupportTagAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SupportTag>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+    };
+    /** HTML→PDF generation and report delivery */
+    readonly documents: {
+        generatePdf: (params: import("./namespaces/documents").GeneratePdfParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/documents").GeneratePdfResponse>;
+        emailReport: (params: import("./namespaces/documents").EmailReportParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/documents").EmailReportResponse>;
+    };
+    /** Document upload, processing, results, and exports */
+    readonly extraction: {
+        documents: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            view: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            bulkDelete: (ids: string[], options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").BulkOperationResult>;
+            reprocess: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            bulkReprocess: (documentIds: string[], options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").BulkReprocessResult>;
+            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            status: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").DocumentStatusResponse>;
+            beginUpload: (attrs: import("./namespaces/extraction").BeginUploadAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            findOrBeginUpload: (attrs?: import("./namespaces/extraction").FindOrBeginUploadAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            finishUpload: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            stats: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").DocumentStatsResponse>;
+            dismiss: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            updateVerification: (id: string, attrs: import("./namespaces/extraction").UpdateVerificationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            dismissAllTrained: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").DismissAllTrainedResult>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument[]>;
+            upload: (file: File | Blob, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionDocument>;
+            presignedUpload: (attrs: import("./namespaces/extraction").ExtractionPresignedUploadAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").ExtractionPresignedUploadResponse>;
+        };
+        results: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult>;
+            update: (id: string, attributes: import("./namespaces/extraction").UpdateExtractionResultAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            byDocument: (documentId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult[]>;
+            regenerate: (id: string, attrs: import("./namespaces/extraction").RegenerateResultAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult>;
+            saveCorrections: (id: string, attrs: import("./namespaces/extraction").SaveCorrectionsAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionResult[]>;
+            query: (resultId: string, params?: import("./namespaces/extraction").ExtractionRowQueryParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").ExtractionRowQueryResult>;
+        };
+        batches: {
+            create: (attributes: import("./namespaces/extraction").CreateExtractionBatchAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionBatch>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionBatch>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionBatch[]>;
+        };
+        exports: {
+            list: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").ExtractionExportRecord[]>;
+            create: (workspaceId: string, attrs: import("./namespaces/extraction").CreateExtractionExportAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").ExtractionExportRecord>;
+            get: (workspaceId: string, id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").ExtractionExportRecord>;
+        };
+        schemaDiscoveries: {
+            create: (attrs: import("./namespaces/extraction").CreateSchemaDiscoveryAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").SchemaDiscoveryRecord>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").SchemaDiscoveryRecord>;
+        };
+        fieldTemplates: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").FieldTemplateRecord[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").FieldTemplateRecord>;
+            create: (attrs: import("./namespaces/extraction").CreateFieldTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").FieldTemplateRecord>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        fieldMappings: {
+            get: (workspaceId: string, documentId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").FieldMappingRecord>;
+            create: (workspaceId: string, documentId: string, attrs: import("./namespaces/extraction").CreateFieldMappingAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").FieldMappingRecord>;
+        };
+        extractionAgents: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionAgent[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").ExtractionAgent>;
+            predict: (attributes: {
+                name?: string;
+                description?: string;
+                file_content?: string;
+                document_id?: string;
+                [key: string]: unknown;
+            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        };
+        trainingAnalytics: {
+            forWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingAnalytics>;
+        };
+    };
+    /** User authentication, profiles, and API key management */
+    readonly identity: {
+        login: (email: string, password: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        refresh: (refreshToken: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").RefreshResponse>;
+        register: (email: string, password: string, passwordConfirmation: string, tenantName: string, attrs?: import("./namespaces/identity").RegisterExtraAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        registerViaInvitation: (email: string, password: string, passwordConfirmation: string, invitationToken: string, attrs?: import("./namespaces/identity").RegisterExtraAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        me: (options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        profile: (options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & import("./base-client").RequestOptions) => Promise<import(".").User[]>;
+        listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").User[]>;
+        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        create: (attributes: import("./namespaces/identity").CreateUserAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        resendConfirmation: (email: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
+        confirmEmail: (email: string, confirmationToken: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").AuthResponse>;
+        requestMagicLink: (email: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").AuthResponse>;
+        requestPasswordReset: (email: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").AuthResponse>;
+        signInWithMagicLink: (token: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").AuthResponse>;
+        resetPasswordWithToken: (token: string, password: string, passwordConfirmation: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").AuthResponse>;
+        changePassword: (currentPassword: string, password: string, passwordConfirmation: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").AuthResponse>;
+        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        myTenants: (options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant[]>;
+        myDashboard: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").DashboardResponse>;
+        myStats: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").UserStatsResponse>;
+        myActivity: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").AuthResponse[]>;
+        tokens: {
+            create: (attributes: import("./namespaces/identity").CreateTokenAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Token>;
+        };
+        profiles: {
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").UserProfile[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
+            create: (attributes: import("./namespaces/identity").CreateUserProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
+            update: (id: string, attributes: import("./namespaces/identity").UpdateUserProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
+            me: (options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
+            acceptTos: (id: string, tosVersion: string, privacyPolicyVersion?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
+            dismissWelcome: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
+            dismissAnnouncement: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
+        };
+        oauth: {
+            getAuthorizationUrl(provider: import("./namespaces/identity").OAuthProvider, options: import("./namespaces/identity").OAuthSignInOptions): string;
+            signIn(provider: import("./namespaces/identity").OAuthProvider, options: import("./namespaces/identity").OAuthSignInOptions): void;
+        };
+        apiKeys: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").ApiKey[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey[]>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            update: (id: string, attributes: import("./namespaces/identity").UpdateApiKeyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
+            create: (name: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
+            revoke: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
+            rotate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
+            setBudget: (id: string, creditLimit: number | null, creditLimitPeriod: string | null, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
+            usageStats: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/identity").ApiKeyUsageStat[]>;
+            active: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").ApiKey[]>;
+            resetBudgetPeriod: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
+        };
+    };
+    /** Customer portal operations: auth, profile, forms, notifications, chat */
+    readonly portal: {
+        auth: {
+            requestMagicLink: (email: string, tenantId: string, options?: import("./base-client").RequestOptions) => Promise<{
+                message: string;
+            }>;
+            verifyMagicLink: (magicToken: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalAuthResponse>;
+            verify: (token: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalAuthResponse>;
+            login: (email: string, password: string, tenantId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalAuthResponse>;
+            refresh: (refreshToken: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalAuthResponse>;
+        };
+        profile: {
+            get: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalProfile>;
+            update: (params: {
+                avatar_url?: string;
+                locale?: string;
+                timezone?: string;
+                notification_preferences?: Record<string, unknown>;
+            }, options?: import("./base-client").RequestOptions) => Promise<{
+                id: string;
+                status: string;
+            }>;
+        };
+        forms: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalForm[];
+            }>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalForm;
+            }>;
+            submit: (formId: string, data: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalFormSubmissionResult>;
+        };
+        notifications: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalNotification[];
+            }>;
+            markRead: (id: string, options?: import("./base-client").RequestOptions) => Promise<{
+                id: string;
+                read_at: string;
+            }>;
+        };
+        changeRequests: {
+            create: (fieldName: string, newValue: string, oldValue?: string, options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalChangeRequest;
+            }>;
+            list: (options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalChangeRequest[];
+            }>;
+        };
+        threads: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalThread[];
+            }>;
+            create: (title?: string, options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalThread;
+            }>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalThread;
+            }>;
+            sendMessage: (threadId: string, message: string, options?: import("./base-client").RequestOptions) => Promise<{
+                data: import("./namespaces/portal").PortalMessageResponse;
+            }>;
+        };
+    };
+    /** Workspaces, applications, tenants, and invitations */
+    readonly platform: {
+        workspaces: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
+            mine: (options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
+            shared: (options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
+            create: (name: string, slug?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
+            listExtractionExportsByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
+            listAllExtractionExportsByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            update: (id: string, attributes: import("./namespaces/platform").UpdateWorkspaceAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
+            updateStorageSettings: (id: string, settings: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
+            allocateCredits: (workspaceId: string, amount: number, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
+            populateHashes: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
+        };
+        applications: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").Application[]>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            create: (attributes: import("./namespaces/platform").CreateApplicationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Application>;
+            update: (id: string, attributes: import("./namespaces/platform").UpdateApplicationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Application>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Application>;
+            readCurrent: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Application>;
+            getBySlug: (slug: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Application>;
+        };
+        tenants: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Tenant[]>;
+            listDocumentStats: (tenantId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Tenant[]>;
+            listAllDocumentStats: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant[]>;
+            credit: (id: string, amount: number, description?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            deactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            reactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            create: (attributes: import("./namespaces/platform").CreateTenantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            update: (id: string, attributes: import("./namespaces/platform").UpdateTenantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            schedulePurge: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            transferOwnership: (tenantId: string, newOwnerId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            convertToOrg: (tenantId: string, attributes: {
+                name: string;
+                slug?: string;
+                application_id?: string;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            createOrg: (attributes: {
+                name: string;
+                logo_url?: string;
+                [key: string]: unknown;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+            createPersonal: (options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
+        };
+        invitations: {
+            accept: (id: string, token: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
+            decline: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
+            revoke: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
+            listMe: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Invitation[]>;
+            listAllMe: (options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation[]>;
+            create: (attributes: import("./namespaces/platform").CreateInvitationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
+            resend: (id: string, applicationId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").Invitation[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation[]>;
+            consumeByToken: (token: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation | null>;
+            acceptByToken: (token: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
+        };
+        roles: {
+            list: () => Promise<{
+                data?: Array<import("./_internal/types.gen").Role>;
+            }>;
+            create: (name: string, permissions: string[]) => Promise<{
+                data?: import("./_internal/types.gen").Role;
+            }>;
+            update: (id: string, attributes: Partial<{
+                name: string;
+                permissions: string[];
+            }>) => Promise<{
+                data?: import("./_internal/types.gen").Role;
+            }>;
+            destroy: (id: string) => Promise<void>;
+        };
+        permissions: {
+            list: (params?: Record<string, string>) => Promise<{
+                data?: Array<import("./_internal/types.gen").Permission>;
+            }>;
+            get: (id: string) => Promise<{
+                data?: import("./_internal/types.gen").Permission;
+            }>;
+            meta: () => Promise<unknown>;
+            presets: {
+                list: (params?: Record<string, string>) => Promise<{
+                    data?: Array<import("./_internal/types.gen").PermissionPreset>;
+                }>;
+                get: (id: string) => Promise<{
+                    data?: import("./_internal/types.gen").PermissionPreset;
+                }>;
+            };
+        };
+        brandIdentities: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity>;
+            create: (attributes: import("./namespaces/platform").CreateBrandIdentityAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity>;
+            update: (id: string, attributes: import("./namespaces/platform").UpdateBrandIdentityAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByTenant: (tenantId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity[]>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity[]>;
+            getDefaultForTenant: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity>;
+            getDefaultForWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity>;
+            setDefault: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity>;
+            unsetDefault: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").BrandIdentity>;
+        };
+        platformTones: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").PlatformTone[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PlatformTone>;
+            create: (attributes: import("./namespaces/platform").CreatePlatformToneAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PlatformTone>;
+            update: (id: string, attributes: import("./namespaces/platform").UpdatePlatformToneAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").PlatformTone>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            listByBrand: (brandIdentityId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").PlatformTone[]>;
+        };
+    };
+    /** Event types, scheduled events, bookings, participants, and calendar sync */
+    readonly scheduling: {
+        eventTypes: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEventType[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEventType[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEventType>;
+            create: (attributes: import("./namespaces/scheduling").CreateSchedulingEventTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEventType>;
+            update: (id: string, attributes: import("./namespaces/scheduling").UpdateSchedulingEventTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEventType>;
+            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEventType>;
+            getBySlug: (slug: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEventType>;
+        };
+        events: {
+            list: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent[]>;
+            listAll: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent>;
+            create: (attributes: import("./namespaces/scheduling").CreateSchedulingEventAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent>;
+            update: (id: string, attributes: import("./namespaces/scheduling").UpdateSchedulingEventAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent>;
+            cancel: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent>;
+            complete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent>;
+            reschedule: (id: string, attributes: {
+                new_start_time: string;
+                new_end_time: string;
+            }, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent>;
+            listByDateRange: (workspaceId: string, startTime: string, endTime: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent[]>;
+            listByParticipant: (email: string, workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingEvent[]>;
+        };
+        participants: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingParticipant[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingParticipant[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingParticipant>;
+            create: (attributes: import("./namespaces/scheduling").CreateSchedulingParticipantAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingParticipant>;
+            update: (id: string, attributes: import("./namespaces/scheduling").UpdateSchedulingParticipantAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingParticipant>;
+            respond: (id: string, status: "accepted" | "declined" | "tentative", options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingParticipant>;
+            remove: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        };
+        bookings: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking>;
+            create: (attributes: import("./namespaces/scheduling").CreateSchedulingBookingAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking>;
+            confirm: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking>;
+            cancel: (id: string, attributes?: import("./namespaces/scheduling").CancelSchedulingBookingAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking>;
+            reschedule: (id: string, attributes: import("./namespaces/scheduling").RescheduleSchedulingBookingAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking>;
+            markNoShow: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking>;
+            listByBooker: (email: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingBooking[]>;
+        };
+        calendarSyncs: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingCalendarSync[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingCalendarSync[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingCalendarSync>;
+            create: (attributes: import("./namespaces/scheduling").CreateSchedulingCalendarSyncAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingCalendarSync>;
+            update: (id: string, attributes: import("./namespaces/scheduling").UpdateSchedulingCalendarSyncAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingCalendarSync>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            pause: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingCalendarSync>;
+            resume: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SchedulingCalendarSync>;
+        };
+        sessionNotes: {
+            get: (eventId: string, noteType: import("./namespaces/session-notes").SessionNoteType, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataStoreRecord | null>;
+            upsert: (eventId: string, noteType: import("./namespaces/session-notes").SessionNoteType, workspaceId: string, value: import("./namespaces/session-notes").SessionNoteValue, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").DataStoreRecord>;
+        };
+    };
+    /** Full-text, semantic, and saved search operations */
+    readonly search: {
+        query: (query: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/search").SearchResponse>;
+        semantic: (query: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/search").SearchResponse>;
+        suggest: (query: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/search").SuggestResponse>;
+        indexes: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/search").IndexesResponse>;
+        saved: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SavedSearch[]>;
+            create: (attributes: import("./namespaces/search").CreateSavedSearchAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").SavedSearch>;
+            run: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/search").SearchResponse>;
+        };
+    };
+    /** Bucket and object management, presigned URLs */
+    readonly storage: {
+        signUpload: (attributes?: import("./namespaces/storage").PresignedUploadAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/storage").PresignedUploadResponse>;
+        buckets: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").Bucket[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Bucket[]>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            create: (attributes: import("./namespaces/storage").CreateBucketAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Bucket>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Bucket>;
+            update: (id: string, attributes: import("./namespaces/storage").UpdateBucketAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").Bucket>;
+        };
+        files: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile>;
+            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile>;
+            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile>;
+            confirmUpload: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile>;
+            softDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile>;
+            tag: (id: string, tags: string[], options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile>;
+            updateMetadata: (id: string, newMetadata: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile>;
+            byChecksum: (checksum: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile[]>;
+            listChildren: (parentId: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").StorageFile[]>;
+            requestDownloadUrl: (id: string, params?: import("./namespaces/storage").RequestDownloadUrlParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/storage").DownloadUrlResponse>;
+        };
+    };
+    /** Conversation threads, messaging, and thread management */
+    readonly threads: {
+        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & import("./base-client").RequestOptions) => Promise<import(".").ChatThread[]>;
+        listMine: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & import("./base-client").RequestOptions) => Promise<import(".").ChatThread[]>;
+        listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread[]>;
+        create: (attributes: import("./namespaces/threads").CreateThreadAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        update: (id: string, attributes: import("./namespaces/threads").UpdateThreadAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        updateMetadata: (id: string, metadata: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        summarize: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        fork: (id: string, title?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        export: (id: string, format?: "json" | "markdown" | "text", options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        unarchive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        messages: {
+            list: (threadId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage[]>;
+            send: (threadId: string, content: string, attributes?: import("./namespaces/threads").SendMessageAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage>;
+            insert: (threadId: string, content: string, attributes: import("./namespaces/threads").InsertMessageAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage>;
+            rate: (messageId: string, rating: "up" | "down", comment?: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/threads").MessageFeedback>;
+            update: (messageId: string, attributes: import("./namespaces/threads").UpdateMessageAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage>;
+            stream: (threadId: string, body: Record<string, unknown>, options?: import("./base-client").RequestOptions, streamOptions?: import("./streaming").StreamOptions) => Promise<AsyncIterableIterator<import("./streaming").StreamMessageChunk>>;
+            search: (query: string, threadId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage[]>;
+            semanticSearch: (query: string, limit?: number, threadId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage[]>;
+        };
+        complete: (threadId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
+        completeStream: (threadId: string, options?: import("./base-client").RequestOptions, streamOptions?: import("./streaming").StreamOptions) => Promise<AsyncIterableIterator<import("./streaming").StreamMessageChunk>>;
+        search: (query: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread[]>;
+    };
+    /** Training examples and sessions */
+    readonly training: {
+        examples: {
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            create: (attributes: import("./namespaces/training").CreateTrainingExampleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            update: (id: string, attributes: import("./namespaces/training").UpdateTrainingExampleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            bulkCreate: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            bulkDestroy: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+            searchByVector: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingExample>;
+        };
+        sessions: {
+            listAgentsSessions: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingSession[]>;
+            listAllAgentsSessions: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingSession[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingSession>;
+            create: (attributes: import("./namespaces/training").CreateTrainingSessionAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingSession>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            update: (agentId: string, attributes: import("./namespaces/training").UpdateTrainingSessionAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").TrainingSession>;
+        };
+    };
+    /** Voice transcription, TTS, and real-time voice session management */
+    readonly voice: {
+        transcribe: (audio: File | Blob, params?: import("./namespaces/voice").VoiceTranscribeOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/voice").VoiceTranscribeResult>;
+        sessions: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+                status?: "active" | "ended" | "failed" | "timed_out";
+                insertedAfter?: string;
+                insertedBefore?: string;
+            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceSession[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceSession>;
+            listMine: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceSession[]>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceSession[]>;
+            start: (params?: import("./namespaces/voice").VoiceStartOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/voice").VoiceSessionStart>;
+            stop: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceSession>;
+            finalize: (id: string, params?: import("./namespaces/voice").VoiceFinalizeOptions, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceSession>;
+            destroy: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
+        };
+        recordings: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceRecording[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceRecording>;
+            bySession: (sessionId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceRecording[]>;
+        };
+        transcriptionResults: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult>;
+            bySession: (sessionId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult[]>;
+            create: (attributes: {
+                text: string;
+                recording_id?: string;
+                session_id?: string;
+                document_id?: string;
+                segments?: Array<{
+                    text: string;
+                    start: number;
+                    end: number;
+                    confidence?: number;
+                }>;
+                language_detected?: string;
+                duration_seconds?: number;
+                processing_seconds?: number;
+                stt_engine?: string;
+                stt_model?: string;
+                metadata?: Record<string, unknown>;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult>;
+            update: (id: string, attributes: {
+                text?: string;
+                segments?: Array<{
+                    text: string;
+                    start: number;
+                    end: number;
+                    confidence?: number;
+                }>;
+                metadata?: Record<string, unknown>;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult>;
+            destroy: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
+        };
+        transcriptionJobs: {
+            create: (params?: import("./namespaces/voice").TranscriptionJobCreateOptions, options?: import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob>;
+            listMine: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob[]>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob[]>;
+            listByWorkspace: (workspaceId: string, options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob[]>;
+            uploadChunk: (jobId: string, audio: File | Blob, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/voice").TranscriptionChunkResult>;
+            finalize: (jobId: string, params?: import("./namespaces/voice").TranscriptionJobFinalizeOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/voice").TranscriptionJobFinalizeResult>;
+            destroy: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
+        };
+    };
+    /** File watcher claims and event management */
+    readonly watcher: {
+        claims: {
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim[]>;
+            claim: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim>;
+            create: (attributes: import("./namespaces/watcher").CreateWatcherClaimAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim>;
+            update: (id: string, attributes: import("./namespaces/watcher").UpdateWatcherClaimAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
+            registerCompleted: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim>;
+            readStatus: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherClaim>;
+        };
+        events: {
+            create: (attributes: import("./namespaces/watcher").CreateWatcherEventAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherEvent>;
+            list: (options?: {
+                page?: number;
+                pageSize?: number;
+            } & import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherEvent[]>;
+            listAll: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherEvent[]>;
+            delete: (options?: import("./base-client").RequestOptions) => Promise<true>;
+            batchCreate: (options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherEvent>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal").WatcherEvent>;
+        };
+    };
+    /** Social media accounts, posts, metrics, and AI campaigns */
+    readonly social: {
+        accounts: {
+            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByPlatform: (platform: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            create: (attributes: import("./namespaces/social").SocialAccountCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            update: (id: string, attributes: import("./namespaces/social").SocialAccountUpdateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            enablePosting: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            disablePosting: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            deactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        };
+        posts: {
+            create: (attributes: import("./namespaces/social").SocialPostCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            update: (id: string, attributes: import("./namespaces/social").SocialPostUpdateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            schedule: (id: string, scheduledAt: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            publishNow: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            retry: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            updateSeo: (id: string, attributes: {
+                seo_score?: number;
+                seo_analysis?: Record<string, unknown>;
+            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listScheduled: (options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByAccount: (socialAccountId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByCampaign: (socialCampaignId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        };
+        metrics: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByPost: (socialPostId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            latestForPost: (socialPostId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            byAccount: (socialAccountId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            byCampaign: (socialCampaignId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        };
+        campaigns: {
+            list: (options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            create: (workspaceId: string, attributes: import("./namespaces/social").SocialCampaignCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            update: (id: string, attributes: import("./namespaces/social").SocialCampaignUpdateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            schedule: (id: string, scheduledAt: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            generateMasterCopy: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            adaptForPlatforms: (id: string, workspaceId: string, socialAccountId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            previewAdaptations: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        };
+        trending: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            create: (attributes: {
+                workspace_id: string;
+                enrichment_level?: "raw" | "scored" | "summarized" | "full";
+                query?: string;
+                source_breakdown?: Record<string, unknown>;
+                item_count?: number;
+                fetched_at?: string;
+            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByDateRange: (from: string, to: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            items: {
+                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+                listBySnapshot: (snapshotId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            };
+        };
+        watches: {
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            create: (attributes: {
+                workspace_id: string;
+                name: string;
+                query: string;
+                sources?: string[];
+                conditions?: Record<string, unknown>;
+                notification_config?: Record<string, unknown>;
+                enabled?: boolean;
+            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            update: (id: string, attributes: {
+                name?: string;
+                query?: string;
+                sources?: string[];
+                conditions?: Record<string, unknown>;
+                notification_config?: Record<string, unknown>;
+                enabled?: boolean;
+            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
+        };
+    };
+    /** Project, milestone, task, time entry, member, risk, and AI management */
+    readonly projects: {
+        list(params?: import("./namespaces/projects").ListProjectsParams, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Project[]>;
+        get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Project>;
+        create(data: import("./namespaces/projects").CreateProjectInput, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Project>;
+        update(id: string, data: import("./namespaces/projects").UpdateProjectInput, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Project>;
+        archive(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
+        milestones: {
+            list(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Milestone[]>;
+            create(projectId: string, data: import("./namespaces/projects").CreateMilestoneInput, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Milestone>;
+        };
+        tasks: {
+            list(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Task[]>;
+            create(data: import("./namespaces/projects").CreateTaskInput, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").Task>;
+            suggestAssignee(taskId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").AssigneeSuggestion[]>;
+        };
+        timeEntries: {
+            list(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").TimeEntry[]>;
+            create(data: import("./namespaces/projects").CreateTimeEntryInput, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").TimeEntry>;
+        };
+        members: {
+            list(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").ProjectMember[]>;
+            add(projectId: string, data: import("./namespaces/projects").AddMemberInput, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").ProjectMember>;
+            remove(projectId: string, memberId: string, options?: import("./base-client").RequestOptions): Promise<void>;
+        };
+        risks: {
+            list(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").ProjectRisk[]>;
+        };
+        activity: {
+            list(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").ProjectActivity[]>;
+        };
+        updates: {
+            list(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").ProjectUpdate[]>;
+        };
+        ai: {
+            decompose(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").DecomposedPlan>;
+            estimateCompletion(projectId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").CompletionEstimate>;
+            getSummary(projectId: string, options?: import("./base-client").RequestOptions): Promise<string>;
+        };
+        templates: {
+            list(options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").ProjectTemplate[]>;
+        };
+        labels: {
+            list(options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").TaskLabel[]>;
+            create(data: import("./namespaces/projects").CreateLabelInput, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/projects").TaskLabel>;
+        };
+        tags: {
+            list(options?: import("./base-client").RequestOptions): Promise<unknown[]>;
+        };
+    };
+    /** Model catalog — available models with tier classification */
+    readonly models: {
+        list(options?: import("./namespaces/models").ListModelsOptions, reqOptions?: import("./base-client").RequestOptions): Promise<import("./namespaces/models").ModelInfo[]>;
+        get(modelId: string, reqOptions?: import("./base-client").RequestOptions): Promise<import("./namespaces/models").ModelInfo>;
+    };
+    /** CRM cluster discovery — AI-labeled relationship clusters via community detection */
+    readonly crmClusters: {
+        discover(workspaceId: string): Promise<{
+            data: import("./namespaces/crm-clusters").CrmCluster[];
+        }>;
+    };
+    /** Pipeline execution polling and HITL checkpoint management */
+    readonly pipelineExecutions: {
+        get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution>;
+        list(workspaceId: string, filters?: {
+            status?: import("./namespaces/pipeline-executions").PipelineExecutionStatus;
+            pipeline_id?: string;
+        }, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution[]>;
+        listByPipeline(pipelineId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution[]>;
+        approve(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution>;
+        reject(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution>;
+        updateCheckpoint(id: string, attributes: import("./namespaces/pipeline-executions").UpdateCheckpointAttributes, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution>;
+        addNote(id: string, note: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution>;
+        aiRefine(id: string, nodeId: string, instruction: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-executions").PipelineExecution>;
+    };
+    /** Pipeline trigger — execute multi-node agent pipelines */
+    readonly pipelines: {
+        list(options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipelines").Pipeline[]>;
+        get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipelines").Pipeline>;
+        getBySlug(slug: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipelines").Pipeline>;
+        trigger(id: string, attributes: import("./namespaces/pipelines").TriggerPipelineAttributes, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipelines").PipelineTriggerResponse>;
+        dryRun(id: string, attributes: import("./namespaces/pipelines").DryRunAttributes, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipelines").DryRunResponse>;
+    };
+    /** Access grants — workspace and tenant role assignments (ReBAC) */
+    readonly accessGrants: {
+        list(params?: Record<string, string>): Promise<import("./namespaces/access-grants").AccessGrantListResult>;
+        get(id: string): Promise<import("./namespaces/access-grants").AccessGrantResult>;
+        create(attrs: import("./_internal").PostAccessGrantsData["body"]): Promise<import("./namespaces/access-grants").AccessGrantResult>;
+        update(id: string, attrs: import("./_internal").PatchAccessGrantsByIdData["body"]): Promise<import("./namespaces/access-grants").AccessGrantResult>;
+        revoke(id: string): Promise<void>;
+    };
+    /** Roles — permission bundles for assignment via access grants */
+    readonly roles: {
+        list(params?: Record<string, string>): Promise<import("./namespaces/roles").RoleListResult>;
+        get(id: string): Promise<import("./namespaces/roles").RoleResult>;
+        create(attrs: import("./_internal").PostRolesData["body"]): Promise<import("./namespaces/roles").RoleResult>;
+        update(id: string, attrs: import("./_internal").PatchRolesByIdData["body"]): Promise<import("./namespaces/roles").RoleResult>;
+        delete(id: string): Promise<void>;
+    };
+    /** Permissions — platform permission registry, presets, and metadata */
+    readonly permissions: {
+        list(params?: Record<string, string>): Promise<import("./namespaces/permissions").PermissionListResult>;
+        get(id: string): Promise<import("./namespaces/permissions").PermissionResult>;
+        meta(): Promise<import("./namespaces/permissions").PermissionMetaResult>;
+        listPresets(params?: Record<string, string>): Promise<import("./namespaces/permissions").PermissionPresetListResult>;
+        getPreset(id: string): Promise<import("./namespaces/permissions").PermissionPresetResult>;
+    };
+    /** Structured document sections — section documents and document sections */
+    readonly memory: {
+        sectionDocuments: {
+            list: (params?: {
+                page?: number;
+                pageSize?: number;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").SectionDocument[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SectionDocument>;
+        };
+        documentSections: {
+            list: (params?: {
+                page?: number;
+                pageSize?: number;
+            }, options?: import("./base-client").RequestOptions) => Promise<import(".").DocumentSection[]>;
+            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").DocumentSection>;
+        };
+    };
+    /** Scoped channel tokens for WebSocket authentication */
+    readonly channels: {
+        authorize(request: import("./namespaces/channels").ChannelTokenRequest, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/channels").ChannelTokenResponse>;
+        createTokenManager(options: Omit<import("./namespaces/channels").SocketManagerOptions, "socketUrl">): Promise<import("./namespaces/channels").SocketManager>;
+    };
+    /** Unified import hub — CSV/JSON batch imports across Clinical, CRM, and Catalog */
+    readonly imports: {
+        listAdapters: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/imports").ImportAdapter[]>;
+        batch: (params: {
+            adapter: string;
+            workspace_id: string;
+            rows: Record<string, unknown>[];
+            metadata?: Record<string, unknown>;
+        }, options?: import("./base-client").RequestOptions) => Promise<{
+            data: {
+                import_id: string;
+                status: string;
+            };
+        }>;
+        upload: (file: File | Blob, params: {
+            adapter: string;
+            workspace_id: string;
+            column_mapping? /** Wallet, plans, transactions, and payment methods */: Record<string, string>;
+            metadata?: Record<string, unknown>;
+        }, options?: import("./base-client").RequestOptions) => Promise<{
+            data: {
+                import_id: string;
+                status: string;
+            };
+        }>;
+        list: (params: {
+            workspace_id: string;
+            adapter?: string;
+            status?: string;
+            offset?: number;
+            limit?: number;
+        }, options?: import("./base-client").RequestOptions) => Promise<{
+            data: import("./namespaces/imports").Import[];
+            meta: {
+                count: number;
+            };
+        }>;
+        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/imports").Import>;
+        rows: (importId: string, params?: {
+            offset?: number;
+            limit?: number;
+        }, options?: import("./base-client").RequestOptions) => Promise<{
+            data: import("./namespaces/imports").ImportRow[];
+            meta: {
+                count: number;
+            };
+        }>;
+        confirm: (id: string, params: {
+            workspace_id: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<{
+            data: {
+                import_id: string;
+                status: string;
+            };
+        }>;
+        cancel: (id: string, params: {
+            workspace_id: string;
+        }, options?: import("./base-client").RequestOptions) => Promise<{
+            data: {
+                import_id: string;
+                status: string;
+            };
+        }>;
+    };
+    constructor(config?: BaseClientConfig);
+    /**
+     * Subscribe to SDK lifecycle events.
+     * Returns an unsubscribe function for cleanup.
+     *
+     * @example
+     * ```typescript
+     * const client = new GptClient({ apiKey: 'sk_...' });
+     *
+     * // Listen for all requests
+     * const unsubscribe = client.on('request', (event) => {
+     *   console.log(`${event.method} ${event.url}`);
+     * });
+     *
+     * // Listen for responses
+     * client.on('response', (event) => {
+     *   console.log(`${event.status} in ${event.duration}ms`);
+     * });
+     *
+     * // Clean up
+     * unsubscribe();
+     * ```
+     */
+    on<K extends keyof SdkEvents>(event: K, handler: (event: SdkEvents[K]) => void): () => void;
+}
+//# sourceMappingURL=gpt-client.d.ts.map