@specstream/sdk 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SpecStream SAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,71 @@
-# Temporary Holding Version
+# @specstream/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+TypeScript client for [SpecStream](https://specstream.ai), the live web data engine for teams and agents. Describe the list you need in plain words; SpecStream reads the web where those things live, hands back only the matches, each with the page it came from, and you pay only for the matches.
+
+The client has no runtime dependencies and needs Node 22 or newer. It uses the same account, permissions, projects and balance as the workspace.
+
+```sh
+npm install @specstream/sdk
+```
+
+Create an API key under **Agents & API** in your SpecStream workspace and keep it in the environment: `SPECSTREAM_API_KEY`.
+
+## Read a request, get the price
+
+```ts
+import { Client } from "@specstream/sdk";
+
+const client = new Client({ apiKey: process.env.SPECSTREAM_API_KEY! });
+
+const read = await client.compile(
+  "Open-source document-signing tools I can self-host. Include the license and latest release.",
+);
+const offer = await client.quoteCapacityWork({
+  ast_hash: String(read.ast_hash),
+  operation: "find",
+  requested_units: 25,
+});
+console.log(offer.maximum_cents, offer.expires_at);
+```
+
+Nothing has run yet. Show a person the quote: what will be found, the facts that come back, the most the work can cost, and when the price expires. A price lasts 30 minutes.
+
+## Approve it, then read the results
+
+After a person approves, send the approved maximum in cents and a request key you saved first:
+
+```ts
+const run = await client.authorizeCapacityWork({
+  quote_id: offer.quote_id,
+  quote_hash: offer.quote_hash,
+  confirm_max_cents: approvedMaximumCents,
+  idempotency_key: savedRequestKey,
+});
+
+if (!run.find_id) throw new Error("The work was not started; retry with the same key");
+const page = await client.rows(run.find_id);
+for (const row of page.rows) console.log(row);
+```
+
+If the response is lost, `getCapacityRequest(savedRequestKey)` returns the same work. Keep the original key when you retry, and you will not pay twice. `authorizeCapacityWork` throws before any network call unless the quote, its signature, a whole-number maximum and the key are all present. `getFind` reports progress, and `rows` pages with `next_cursor`. Reading, exporting and sharing results you own cost nothing.
+
+## More
+
+- `quoteCapacityWork` also prices `extend`, `add_facts` and `refresh` (a recheck, at half price) on a finished run.
+- `specOptions(kind)` lists the facts you can ask for per kind of thing. `editSpec` changes a request without rereading it.
+- `createCapacitySchedule` keeps a request current inside per-run and per-period limits.
+- `export` and `downloadExport` give CSV, XLSX, JSON or HTML.
+- Errors are `SpecstreamError` with `status`, `code` and `details`.
+
+## Pricing
+
+New accounts start with $10 of work for 30 days, no card. A delivered result costs 10 cents, 30 cents or $1 depending on how many facts it carries. No result, no charge. See [pricing](https://specstream.ai/pricing).
+
+## Links
+
+- [SDK docs](https://specstream.ai/docs/sdk) and [API docs](https://specstream.ai/docs/api)
+- [Source and issues](https://github.com/Specstreamai/specstream-tools)
+- [Python client](https://pypi.org/project/specstream-client/)
+- Support: support@specstream.ai
+
+MIT license.

package/dist/authorization.d.ts

@@ -0,0 +1,2 @@
+/** Explicit review is required even when JavaScript bypasses static types. */
+export declare function requireWorkAuthorization(value: unknown): void;

package/dist/authorization.js

@@ -0,0 +1,25 @@
+/** Explicit review is required even when JavaScript bypasses static types. */
+export function requireWorkAuthorization(value) {
+    const required = ["quote_id", "quote_hash", "idempotency_key", "confirm_max_cents"];
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Provide the exact signed-work authorization");
+    }
+    const body = value;
+    const allowed = new Set([...required, "authority_id"]);
+    if (!required.every(key => Object.hasOwn(body, key)) || Object.keys(body).some(key => !allowed.has(key))) {
+        throw new Error("Provide the exact quote identity, signature, maximum cents and request key");
+    }
+    if (typeof body.quote_id !== "string" || !body.quote_id ||
+        typeof body.quote_hash !== "string" || !/^[0-9a-f]{64}$/.test(body.quote_hash)) {
+        throw new Error("The reviewed quote identity and signature are required");
+    }
+    if (typeof body.idempotency_key !== "string" || body.idempotency_key.length < 8 || body.idempotency_key.length > 128) {
+        throw new Error("Use a stable request key containing 8 to 128 characters");
+    }
+    if (typeof body.confirm_max_cents !== "number" || !Number.isSafeInteger(body.confirm_max_cents) || body.confirm_max_cents < 0) {
+        throw new Error("The approved maximum must be an explicit nonnegative integer in cents");
+    }
+    if (body.authority_id !== undefined && body.authority_id !== null && typeof body.authority_id !== "string") {
+        throw new Error("Authority must be an explicit existing identifier");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,304 @@
+/** OpenAPI-aligned SPECSTREAM SDK: compile, quote capacity work, explicitly authorize, receive a Delivery. */
+import type { Schemas } from "./work-types.js";
+export type { Schemas } from "./work-types.js";
+export declare const FAMILIES: readonly ["local_business", "creator", "organization", "storefront_product", "app_listing", "job_posting", "scholarly_work", "tender", "grant", "software_repository", "software_package", "dataset", "clinical_trial", "regulatory_document", "vulnerability", "book", "podcast", "web_page", "knowledge_entity", "person"];
+export type EntityType = (typeof FAMILIES)[number];
+export declare const DEFAULT_BASE_URL = "https://api.specstream.ai";
+export declare class SpecstreamError extends Error {
+    readonly status: number | null;
+    readonly body: unknown;
+    readonly code: string | null;
+    readonly details: Record<string, unknown>;
+    constructor(message: string, status?: number | null, body?: unknown);
+}
+export declare function assertFamily(entityType: string): EntityType;
+export type FetchFn = (input: string, init?: RequestInit) => Promise<Response>;
+export type ClientOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: FetchFn;
+    exportOrigin?: string;
+    timeoutMs?: number;
+};
+export type JsonMap = Record<string, unknown>;
+export declare class Client {
+    readonly apiKey: string;
+    readonly baseUrl: string;
+    private readonly fetchFn;
+    private readonly exportOrigin?;
+    private readonly timeoutMs;
+    constructor(options: ClientOptions);
+    families(): readonly EntityType[];
+    compile(q: string, locale?: string): Promise<JsonMap>;
+    editSpec(ast: JsonMap, operations?: JsonMap[]): Promise<JsonMap>;
+    specOptions(target: string): Promise<JsonMap>;
+    getFind(findId: string): Promise<JsonMap>;
+    revisit(findId: string, after?: string, limit?: number): Promise<JsonMap>;
+    rows(findId: string, cursor?: string | null, limit?: number): Promise<Schemas["FindRowsPage"]>;
+    export(findId: string, format?: string): Promise<JsonMap>;
+    /** Fetch a fresh one-use export. Account credentials never accompany its capability. */
+    downloadExport(findId: string, format?: "xlsx" | "csv" | "json" | "html", maxBytes?: number): Promise<Uint8Array>;
+    getVocabulary(): Promise<Schemas["VocabularyData"]>;
+    workspaceListAuditEvents(query?: {
+        "project_id"?: string;
+        "actor_account_id"?: string;
+        "cursor"?: string;
+        "kind"?: "Sign-in" | "Access" | "Spending" | "Exports" | "Automation" | "Lists";
+        "limit"?: number;
+    }): Promise<Schemas["WorkspaceAuditPage"]>;
+    understandLive(request: Schemas["LiveUnderstandingRequest"]): Promise<Schemas["LiveUnderstandingResult"]>;
+    workspaceSearch(query: {
+        "q": string;
+        "limit"?: number;
+        "cursor"?: string;
+    }): Promise<Schemas["WorkspaceSearchPage"]>;
+    workspaceListNotifications(query?: {
+        "tab"?: "all" | "unread" | "archived";
+        "limit"?: number;
+        "cursor"?: string;
+    }): Promise<Schemas["WorkspaceNotificationPage"]>;
+    workspaceUpdateNotification(identifier: string, request: Schemas["NotificationPatch"]): Promise<Schemas["WorkspaceNotification"]>;
+    workspaceReadNotifications(request: Schemas["NotificationRead"]): Promise<Schemas["WorkspaceNotifications"]>;
+    getMe(): Promise<Schemas["MeData"]>;
+    getAccount(): Promise<Schemas["AccountData"]>;
+    listAccountKeys(): Promise<{
+        "keys": Array<Schemas["KeyListItem"]>;
+    }>;
+    createAccountKey(request: Schemas["KeyCreateRequest"]): Promise<Schemas["KeyCreateData"]>;
+    updateAccountSpend(request: Schemas["AccountSpendRequest"]): Promise<Schemas["AccountSpendData"]>;
+    revokeAccountKey(keyId: string): Promise<{
+        "revoked": true;
+    }>;
+    getFindCommerce(findId: string): Promise<Schemas["CommerceData"]>;
+    reconcileFindCommerce(findId: string): Promise<Schemas["CommerceData"]>;
+    cancelFind(findId: string): Promise<Schemas["CancelData"]>;
+    shareFind(findId: string, request: Schemas["ShareCreateRequest"]): Promise<Schemas["ShareData"]>;
+    revokeShare(shareId: string, request?: Schemas["ShareRevokeRequest"]): Promise<{
+        "share_id": string;
+        "revoked": true;
+    }>;
+    createSpec(request: Schemas["SpecCreateRequest"]): Promise<Schemas["SavedSpec"]>;
+    listSpecs(query?: {
+        "limit"?: number;
+        "cursor"?: string;
+        "project_id"?: string;
+        "archived"?: boolean;
+    }): Promise<Schemas["SpecPage"]>;
+    getSpec(specId: string): Promise<Schemas["SavedSpec"]>;
+    reviseSpec(specId: string, request: Schemas["SpecRevisionRequest"]): Promise<Schemas["SavedSpec"]>;
+    listSpecRevisions(specId: string, query?: {
+        "limit"?: number;
+        "cursor"?: string;
+    }): Promise<Schemas["RevisionPage"]>;
+    getSpecRevision(specId: string, revisionId: string): Promise<Schemas["SpecRevision"]>;
+    archiveSpec(specId: string, request: Schemas["SpecArchiveRequest"]): Promise<Schemas["SavedSpec"]>;
+    listSpecFinds(specId: string, query?: {
+        "limit"?: number;
+        "cursor"?: string;
+    }): Promise<Schemas["LineagePage"]>;
+    getFindLineage(findId: string): Promise<Schemas["FindLineage"]>;
+    getDelivery(findId: string): Promise<Schemas["DeliveryProjection"]>;
+    getFindDecisions(findId: string, query?: {
+        "limit"?: number;
+        "cursor"?: string;
+    }): Promise<Schemas["DecisionPage"]>;
+    createProject(request: Schemas["ProjectCreateRequest"]): Promise<Schemas["Project"]>;
+    listProjects(query?: {
+        "limit"?: number;
+        "cursor"?: string;
+    }): Promise<Schemas["ProjectPage"]>;
+    getProject(projectId: string): Promise<Schemas["Project"]>;
+    updateProject(projectId: string, request: Schemas["ProjectPatchRequest"]): Promise<Schemas["Project"]>;
+    putProjectMember(projectId: string, request: Schemas["ProjectMemberRequest"]): Promise<Schemas["ProjectMember"]>;
+    listProjectMembers(projectId: string, query?: {
+        "limit"?: number;
+        "cursor"?: string;
+    }): Promise<Schemas["MemberPage"]>;
+    revokeProjectMember(projectId: string, accountId: string): Promise<Schemas["MemberRevokeData"]>;
+    listCustomerWebhooks(): Promise<Schemas["CustomerWebhookListData"]>;
+    createCustomerWebhook(request: Schemas["CustomerWebhookRequest"]): Promise<Schemas["CustomerWebhookData"]>;
+    revokeCustomerWebhook(hookId: string): Promise<{
+        "revoked": boolean;
+    }>;
+    getCapacityCatalog(): Promise<{
+        [key: string]: unknown;
+    }>;
+    getCapacityBalance(query?: {
+        "project_id"?: string;
+    }): Promise<Schemas["CapacityBalanceData"]>;
+    getCapacityEntitlements(query?: {
+        "project_id"?: string;
+    }): Promise<Schemas["CapacityEntitlementsData"]>;
+    getCapacityReferral(): Promise<Schemas["CapacityReferralData"]>;
+    captureCapacityReferral(request: Schemas["CapacityReferralVisitRequest"]): Promise<Schemas["CapacityReferralVisitData"]>;
+    getCapacityHistory(): Promise<Schemas["CapacityHistoryData"]>;
+    claimFreeCapacity(): Promise<Schemas["CapacityBalanceData"]>;
+    setCapacityBudget(request: Schemas["CapacityBalanceLimitRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    quoteCapacityWork(request: Schemas["CapacityQuoteRequest"]): Promise<Schemas["CapacityQuoteData"]>;
+    getCapacityQuote(quoteId: string): Promise<Schemas["CapacityQuoteData"]>;
+    authorizeCapacityWork(request: Schemas["CapacityAuthorizeRequest"]): Promise<Schemas["CapacityExecutionData"]>;
+    getCapacityRequest(requestKey: string, query?: {
+        "project_id"?: string;
+    }): Promise<{
+        [key: string]: unknown;
+    }>;
+    getCapacityExecution(findId: string): Promise<Schemas["CommerceData"]>;
+    createCapacityFunding(request: Schemas["CapacityFundingRequest"]): Promise<Schemas["CapacityFundingData"]>;
+    getCapacityFunding(fundingId: string): Promise<Schemas["CapacityFundingData"]>;
+    cancelCapacityFunding(fundingId: string): Promise<Schemas["CapacityFundingData"]>;
+    getCapacityMembership(): Promise<Schemas["CapacityMembershipStatusData"]>;
+    changeCapacityMembership(request: Schemas["CapacityMembershipRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    createCapacityAuthority(request: Schemas["CapacityAuthorityRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    revokeCapacityAuthority(authorityId: string): Promise<{
+        [key: string]: unknown;
+    }>;
+    createCapacitySchedule(request: Schemas["CapacityScheduleRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    listCapacitySchedules(query?: {
+        "project_id"?: string;
+        "after"?: string;
+        "limit"?: number;
+    }): Promise<{
+        [key: string]: unknown;
+    }>;
+    updateCapacitySchedule(scheduleId: string, request: Schemas["CapacitySchedulePatch"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    listCapacityOccurrences(scheduleId: string, query?: {
+        "before"?: string;
+        "limit"?: number;
+    }): Promise<{
+        [key: string]: unknown;
+    }>;
+    runCapacityScheduleNow(scheduleId: string): Promise<{
+        [key: string]: unknown;
+    }>;
+    createCapacityRefundClaim(request: Schemas["CapacityRefundRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    listCapacityRefundClaims(): Promise<Schemas["CapacityRefundClaimsData"]>;
+    getCapacityRefundClaim(claimId: string): Promise<{
+        [key: string]: unknown;
+    }>;
+    requestCapacityCustomPlan(request: Schemas["CapacityCustomRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    getCapacityStoreConfig(): Promise<{
+        [key: string]: unknown;
+    }>;
+    verifyCapacityStorePurchase(request: Schemas["StorePurchaseRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    restoreCapacityStorePurchases(request: Schemas["StoreRestoreRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    transferCapacityStoreToCard(request: Schemas["StoreCardTransferRequest"]): Promise<{
+        [key: string]: unknown;
+    }>;
+    createSpecLink(specId: string, request: Schemas["SpecLinkRequest"]): Promise<Schemas["SpecLinkData"]>;
+    getSharedSpec(token: string): Promise<Schemas["SharedSpec"]>;
+    revokeSpecLink(specId: string, linkId: string): Promise<Schemas["SpecLinkRevoked"]>;
+    workspaceSetScheduleDelivery(scheduleId: string, request: Schemas["ScheduleDeliveryInput"]): Promise<Schemas["ScheduleDeliveryData"]>;
+    workspaceListCollections(query?: {
+        "project_id"?: string;
+        "after"?: string;
+        "limit"?: number;
+        "sort"?: "id" | "recent";
+    }): Promise<Schemas["WorkspaceCollectionPage"]>;
+    workspaceReadCollection(collectionId: string): Promise<Schemas["WorkspaceCollection"]>;
+    workspaceCombineCollections(request: Schemas["CombineCollectionsInput"]): Promise<Schemas["WorkspaceCollection"]>;
+    workspaceCopyCollection(collectionId: string, request: Schemas["CopyCollectionInput"]): Promise<Schemas["WorkspaceCollection"]>;
+    workspaceFilterCollection(collectionId: string, request: Schemas["CollectionFilter"]): Promise<Schemas["WorkspaceCollection"]>;
+    workspaceListViews(collectionId: string): Promise<Schemas["WorkspaceViewList"]>;
+    workspaceSaveView(collectionId: string, request: Schemas["WorkspaceViewSave"]): Promise<Schemas["WorkspaceViewList"]>;
+    workspaceListStars(): Promise<Schemas["WorkspaceStarList"]>;
+    workspaceStarItem(request: Schemas["WorkspaceStarWrite"]): Promise<Schemas["WorkspaceStarList"]>;
+    workspaceListNotes(query?: {
+        "project_id"?: string;
+        "collection_id"?: string;
+        "record_id"?: string;
+    }): Promise<Schemas["WorkspaceNotes"]>;
+    workspaceAddNote(request: Schemas["WorkspaceNoteAdd"]): Promise<Schemas["WorkspaceNotes"]>;
+    workspaceResolveNote(noteId: string, request: Schemas["WorkspaceNoteResolve"]): Promise<Schemas["WorkspaceNotes"]>;
+    workspaceEditNote(noteId: string, request: Schemas["WorkspaceNoteEdit"]): Promise<Schemas["WorkspaceNotes"]>;
+    workspaceDeleteNote(noteId: string, request: Schemas["WorkspaceNoteDelete"]): Promise<Schemas["WorkspaceNotes"]>;
+    workspaceRegisterWebPushSubscription(request: Schemas["WebPushSubscriptionInput"]): Promise<Schemas["PushDevice"]>;
+    workspacePushCapabilities(): Promise<Schemas["PushCapabilities"]>;
+    workspaceListPushDevices(): Promise<Schemas["PushDevicePage"]>;
+    workspaceRegisterPushDevice(request: Schemas["PushDeviceInput"]): Promise<Schemas["PushDevice"]>;
+    workspaceRevokePushDevice(deviceId: string): Promise<Schemas["PushDeviceRevoked"]>;
+    workspaceListYourFields(collectionId: string): Promise<Schemas["YourFields"]>;
+    workspaceSaveYourFields(collectionId: string, request: Schemas["YourFieldsSave"]): Promise<Schemas["YourFields"]>;
+    workspaceSetYourFieldValue(collectionId: string, request: Schemas["YourFieldValue"]): Promise<Schemas["YourFields"]>;
+    beginConnectionAuthorization(provider: string): Promise<Schemas["ConnectedToolData"]>;
+    disconnectConnection(connectionId: string): Promise<Schemas["ConnectedToolData"]>;
+    listCloudImports(): Promise<Schemas["ConnectedToolData"]>;
+    listConnectedTools(): Promise<Schemas["ConnectedToolData"]>;
+    listConnections(): Promise<Schemas["ConnectedToolData"]>;
+    listConnectionDestinations(connectionId: string, query?: {
+        "base_id"?: string;
+        "cursor"?: string;
+    }): Promise<Schemas["ConnectedToolData"]>;
+    getConnectionColumns(connectionId: string, request: Schemas["DestinationRequest"]): Promise<Schemas["ConnectedToolData"]>;
+    saveConnectionDestination(connectionId: string, request: Schemas["DestinationRequest"]): Promise<Schemas["ConnectedToolData"]>;
+    sendToDestination(connectionId: string, request: Schemas["SendToDestinationInput"]): Promise<Schemas["ConnectedToolData"]>;
+    reconcileDestinationExport(connectionId: string, exportId: string): Promise<Schemas["ConnectedToolData"]>;
+    listDestinationExports(): Promise<Schemas["ConnectedToolData"]>;
+    createDestinationSync(request: Schemas["DestinationSyncInput"]): Promise<Schemas["ConnectedToolData"]>;
+    updateDestinationSync(syncId: string, request: Schemas["DestinationSyncUpdate"]): Promise<Schemas["ConnectedToolData"]>;
+    listDestinationSyncs(): Promise<Schemas["ConnectedToolData"]>;
+    previewCloudList(request: Schemas["CloudImportPreview"]): Promise<Schemas["ConnectedToolData"]>;
+    importCloudList(request: Schemas["CloudImportInput"]): Promise<Schemas["ConnectedToolData"]>;
+    updateCloudImport(importId: string, request: Schemas["CloudImportUpdate"]): Promise<Schemas["ConnectedToolData"]>;
+    workspaceInviteMember(request: Schemas["InvitationInput"]): Promise<Schemas["InvitationData"]>;
+    importFileCommand(request: Schemas["FileImportCommand"]): Promise<Schemas["WorkspaceImportData"]>;
+    workspaceActivity(query?: {
+        "project_id"?: string;
+        "cursor"?: string;
+        "limit"?: number;
+    }): Promise<Schemas["ActivityPage"]>;
+    workspaceRelationships(collectionId: string, query?: {
+        "field_id"?: string;
+    }): Promise<Schemas["RelationshipData"]>;
+    workspaceSaveRelationships(collectionId: string, request: Schemas["RelationshipSelection"]): Promise<Schemas["RelationshipData"]>;
+    workspaceReportResult(collectionId: string, request: Schemas["ResultReportInput"]): Promise<Schemas["ResultReportData"]>;
+    listRequestTemplates(query?: {
+        "record_type"?: string;
+    }): Promise<Schemas["RequestTemplateList"]>;
+    workspaceCollectionChanges(collectionId: string): Promise<Schemas["WorkspaceCollectionChanges"]>;
+    workspaceListPasskeys(): Promise<Schemas["PasskeyList"]>;
+    workspaceRegisterPasskeyOptions(): Promise<Schemas["SecurityChallenge"]>;
+    workspaceRegisterPasskey(request: Schemas["PasskeyRegistration"]): Promise<Schemas["PasskeyData"]>;
+    workspaceNamePasskey(credentialId: string, request: Schemas["PasskeyLabel"]): Promise<Schemas["PasskeyData"]>;
+    workspaceDeletePasskey(credentialId: string): Promise<Schemas["SecuritySuccess"]>;
+    workspacePasskeySignInOptions(): Promise<Schemas["SecurityChallenge"]>;
+    workspacePasskeySignIn(request: Schemas["PasskeyComplete"]): Promise<Schemas["SecuritySuccess"]>;
+    workspaceListSSODomains(): Promise<Schemas["SSODomains"]>;
+    workspaceAddSSODomain(request: Schemas["SSODomainInput"]): Promise<Schemas["SSODomain"]>;
+    workspaceVerifySSODomain(domainId: string): Promise<Schemas["SSODomain"]>;
+    workspaceConfigureSSO(domainId: string, request: Schemas["SSOConfigInput"]): Promise<Schemas["SSODomain"]>;
+    workspaceSetSSOPolicy(domainId: string, request: Schemas["SSOPolicyInput"]): Promise<Schemas["SSODomain"]>;
+    workspaceStartSSO(request: Schemas["SSOStartInput"]): Promise<Schemas["SSOStartData"]>;
+    workspaceRotateSCIMToken(domainId: string): Promise<Schemas["SCIMCredential"]>;
+    workspaceRevokeSCIMToken(domainId: string): Promise<Schemas["SecuritySuccess"]>;
+    workspaceReadSCIMMappings(domainId: string): Promise<Schemas["SCIMProvisioning"]>;
+    workspaceSetSCIMMappings(domainId: string, request: Schemas["SCIMMappings"]): Promise<Schemas["SCIMMappings"]>;
+    workspaceReadPhoto(): Promise<Schemas["AccountPhotoData"]>;
+    workspaceDeletePhoto(): Promise<Schemas["AccountPhotoData"]>;
+    workspaceStartNativeProvider(request: Schemas["NativeAuthStart"]): Promise<Schemas["NativeAuthStartData"]>;
+    workspaceRedeemNativeProvider(request: Schemas["NativeAuthRedeem"]): Promise<Schemas["NativeAuthRedeemData"]>;
+    workspacePlacementAllowance(): Promise<Schemas["PlacementMonthlyData"]>;
+    workspaceQuotePlacement(importId: string): Promise<Schemas["PlacementQuoteData"]>;
+    workspaceStartPlacement(importId: string, request: Schemas["PlacementStartInput"]): Promise<Schemas["PlacementStatusData"]>;
+    workspacePlacementStatus(importId: string, placementId: string): Promise<Schemas["PlacementStatusData"]>;
+    private headers;
+    private request;
+}
+export default Client;