@unofficialbox/box-open-sdk 0.1.0

package/dist/esm/tokens.js

@@ -0,0 +1,116 @@
+// Code generated by box-gantry (vendored from runtimes/typescript/gantryruntime/src/tokens.ts). DO NOT EDIT.
+// The shared token machinery behind every exchange flow: the `Auth` contract,
+// the token-endpoint POST, and the single-flight access-token cache. Split out
+// so both `auth.ts` (developer token, CCG, OAuth) and `jwt.ts` (JWT server auth)
+// reuse it without either importing the other, and without leaking these
+// internals into the package's public surface.
+import { BoxApiError } from './errors.js';
+/** Box's OAuth 2.0 token endpoint, shared by every exchange flow. */
+export const DEFAULT_TOKEN_URL = 'https://api.box.com/oauth2/token';
+/** Refresh a cached token this long before expiry, so in-flight requests never
+ * race an expiry. */
+const REFRESH_MARGIN_MS = 60_000;
+/** A hard deadline on a token exchange, so a stalled endpoint can't leave a
+ * single-flight refresh (and every caller awaiting it) hung forever. Matches
+ * the Go runtime's 30s token HTTP client. */
+const TOKEN_TIMEOUT_MS = 30_000;
+/**
+ * Caches an access token and refreshes it — via the flow-specific `refresh` —
+ * when it is missing or within the refresh margin of expiry. Concurrent callers
+ * during a refresh share one in-flight exchange (single-flight), so a token is
+ * never fetched twice at once, and the exchange is not tied to any one caller.
+ */
+export class CachedToken {
+    refresh;
+    token;
+    expiry;
+    inflight;
+    constructor(refresh, seed) {
+        this.refresh = refresh;
+        this.token = seed?.accessToken ?? '';
+        this.expiry = seed ? Date.now() + seed.ttlMs : 0;
+    }
+    async accessToken() {
+        if (this.token && this.expiry - Date.now() > REFRESH_MARGIN_MS) {
+            return this.token;
+        }
+        return this.refreshOnce();
+    }
+    async forceRefresh(stale) {
+        // Another caller may already have refreshed past the rejected token.
+        if (this.token && this.token !== stale) {
+            return this.token;
+        }
+        return this.refreshOnce();
+    }
+    /** Run the flow's refresh, sharing one in-flight exchange across callers. */
+    refreshOnce() {
+        if (!this.inflight) {
+            this.inflight = this.refresh()
+                .then((token) => {
+                this.token = token.accessToken;
+                this.expiry = Date.now() + token.ttlMs;
+                this.inflight = undefined;
+                return token.accessToken;
+            })
+                .catch((err) => {
+                this.inflight = undefined;
+                throw err;
+            });
+        }
+        return this.inflight;
+    }
+}
+/**
+ * POST a form-encoded grant to the token endpoint and normalize the response.
+ * A transport failure and a non-2xx body both surface as a `BoxApiError`, so
+ * token acquisition never escapes the runtime's error contract. The optional
+ * `signal` cancels an explicit caller-initiated exchange (`exchangeCode`); the
+ * cached flows do not thread one, so a shared refresh is never bound to a single
+ * request's cancellation.
+ */
+export async function postTokenForm(tokenUrl, form, signal) {
+    // An internal deadline independent of the caller's signal, combined with it
+    // when present. It also covers the body read, since the signal aborts an
+    // in-progress `fetch` (including body streaming). `AbortSignal.timeout` owns
+    // its own timer, so there is nothing to clear.
+    const deadline = AbortSignal.timeout(TOKEN_TIMEOUT_MS);
+    const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
+    let response;
+    let text;
+    try {
+        response = await fetch(tokenUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+            body: new URLSearchParams(form).toString(),
+            signal: combined,
+        });
+        text = await response.text();
+    }
+    catch (err) {
+        throw new BoxApiError('token endpoint request failed', { cause: err });
+    }
+    if (!response.ok) {
+        throw new BoxApiError(`token endpoint returned ${response.status}: ${text.trim()}`, {
+            status: response.status,
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new BoxApiError('token endpoint returned invalid JSON');
+    }
+    if (!parsed.access_token) {
+        throw new BoxApiError('token endpoint returned no access_token');
+    }
+    return {
+        accessToken: parsed.access_token,
+        refreshToken: parsed.refresh_token ?? '',
+        ttlMs: (parsed.expires_in ?? 0) * 1000,
+    };
+}

package/dist/types/auth.d.ts

@@ -0,0 +1,56 @@
+import { type Auth } from './tokens.js';
+export type { Auth } from './tokens.js';
+/**
+ * The simplest flow: a fixed access token from the Box developer console. A
+ * fixed token cannot be refreshed, so `forceRefresh` returns it unchanged (a
+ * subsequent 401 then surfaces to the caller).
+ */
+export declare function developerToken(token: string): Auth;
+/**
+ * The Client Credentials Grant: server-to-server auth with no signing key. Set
+ * exactly one subject — `enterpriseId` for the service account, or `userId` to
+ * act as a managed user.
+ */
+export interface CcgConfig {
+    clientId: string;
+    clientSecret: string;
+    enterpriseId?: string;
+    userId?: string;
+    /** Optional; defaults to Box's token endpoint. */
+    tokenUrl?: string;
+}
+/** Build a CCG `Auth`. Requires a subject: `enterpriseId` or `userId`. */
+export declare function clientCredentials(config: CcgConfig): Auth;
+/**
+ * The OAuth 2.0 authorization-code flow (a user grants a Box app access). Use
+ * `authorizeUrl` to build the redirect, `exchangeCode` to turn the returned code
+ * into an `Auth`, or `oauth` to resume from a stored refresh token.
+ */
+export interface OAuthConfig {
+    clientId: string;
+    clientSecret: string;
+    /** Optional; defaults to Box's token endpoint. */
+    tokenUrl?: string;
+    /**
+     * Called with each rotated refresh token (Box invalidates the previous one on
+     * every exchange). Persist it so a later `oauth` resume does not start from a
+     * stale, already-invalidated token.
+     */
+    onRefresh?: (refreshToken: string) => void;
+}
+/**
+ * Build the URL to redirect a user to so they can grant access. `state` is
+ * echoed back to the redirect URI for CSRF protection.
+ */
+export declare function authorizeUrl(config: OAuthConfig, redirectUri: string, state: string): string;
+/**
+ * Resume the authorization-code flow from a previously stored refresh token,
+ * exchanging it for access tokens as needed.
+ */
+export declare function oauth(config: OAuthConfig, refreshToken: string): Auth;
+/**
+ * Exchange an authorization code for an `Auth` that refreshes itself thereafter.
+ * The initial refresh token is reported through `config.onRefresh` so it can be
+ * persisted immediately.
+ */
+export declare function exchangeCode(config: OAuthConfig, code: string, redirectUri: string, signal?: AbortSignal): Promise<Auth>;

package/dist/types/buildinfo.d.ts

@@ -0,0 +1,6 @@
+/** The box-gantry engine version that generated this SDK. */
+export declare const ENGINE = "0.1.0";
+/** Fingerprint of the input spec set. */
+export declare const SPEC_FINGERPRINT = "ee7d55aedefe2fa0";
+/** The target language key (FR-4). */
+export declare const TARGET = "typescript";

package/dist/types/client.d.ts

@@ -0,0 +1,176 @@
+import { Auth } from './runtime.js';
+import { AiManager } from './managers/ai.js';
+import { AiStudioManager } from './managers/ai_studio.js';
+import { AppItemAssociationsManager } from './managers/app_item_associations.js';
+import { ArchivesManager } from './managers/archives.js';
+import { AuthorizationManager } from './managers/authorization.js';
+import { AutomateWorkflowsManager } from './managers/automate_workflows.js';
+import { AvatarsManager } from './managers/avatars.js';
+import { ChunkedUploadsManager } from './managers/chunked_uploads.js';
+import { ClassificationsManager } from './managers/classifications.js';
+import { CollaborationAllowlistEntriesManager } from './managers/collaboration_allowlist_entries.js';
+import { CollaborationAllowlistExemptTargetsManager } from './managers/collaboration_allowlist_exempt_targets.js';
+import { CollectionsManager } from './managers/collections.js';
+import { CommentsManager } from './managers/comments.js';
+import { DevicePinnersManager } from './managers/device_pinners.js';
+import { DocgenManager } from './managers/docgen.js';
+import { DocgenTemplateManager } from './managers/docgen_template.js';
+import { DownloadsManager } from './managers/downloads.js';
+import { EmailAliasesManager } from './managers/email_aliases.js';
+import { EnterpriseConfigurationsManager } from './managers/enterprise_configurations.js';
+import { EventsManager } from './managers/events.js';
+import { ExternalUsersManager } from './managers/external_users.js';
+import { FileClassificationsManager } from './managers/file_classifications.js';
+import { FileMetadataManager } from './managers/file_metadata.js';
+import { FileRequestsManager } from './managers/file_requests.js';
+import { FileVersionLegalHoldsManager } from './managers/file_version_legal_holds.js';
+import { FileVersionRetentionsManager } from './managers/file_version_retentions.js';
+import { FileVersionsManager } from './managers/file_versions.js';
+import { FileWatermarksManager } from './managers/file_watermarks.js';
+import { FilesManager } from './managers/files.js';
+import { FolderClassificationsManager } from './managers/folder_classifications.js';
+import { FolderLocksManager } from './managers/folder_locks.js';
+import { FolderMetadataManager } from './managers/folder_metadata.js';
+import { FolderWatermarksManager } from './managers/folder_watermarks.js';
+import { FoldersManager } from './managers/folders.js';
+import { GroupsManager } from './managers/groups.js';
+import { HubCollaborationsManager } from './managers/hub_collaborations.js';
+import { HubDocumentManager } from './managers/hub_document.js';
+import { HubItemsManager } from './managers/hub_items.js';
+import { HubsManager } from './managers/hubs.js';
+import { IntegrationMappingsManager } from './managers/integration_mappings.js';
+import { InvitesManager } from './managers/invites.js';
+import { LegalHoldPoliciesManager } from './managers/legal_hold_policies.js';
+import { LegalHoldPolicyAssignmentsManager } from './managers/legal_hold_policy_assignments.js';
+import { ListCollaborationsManager } from './managers/list_collaborations.js';
+import { MembershipsManager } from './managers/memberships.js';
+import { MetadataCascadePoliciesManager } from './managers/metadata_cascade_policies.js';
+import { MetadataTaxonomiesManager } from './managers/metadata_taxonomies.js';
+import { MetadataTemplatesManager } from './managers/metadata_templates.js';
+import { NotesManager } from './managers/notes.js';
+import { RecentItemsManager } from './managers/recent_items.js';
+import { RetentionPoliciesManager } from './managers/retention_policies.js';
+import { RetentionPolicyAssignmentsManager } from './managers/retention_policy_assignments.js';
+import { SearchManager } from './managers/search.js';
+import { SessionTerminationManager } from './managers/session_termination.js';
+import { SharedLinksAppItemsManager } from './managers/shared_links_app_items.js';
+import { SharedLinksFilesManager } from './managers/shared_links_files.js';
+import { SharedLinksFoldersManager } from './managers/shared_links_folders.js';
+import { SharedLinksWebLinksManager } from './managers/shared_links_web_links.js';
+import { ShieldInformationBarrierReportsManager } from './managers/shield_information_barrier_reports.js';
+import { ShieldInformationBarrierSegmentMembersManager } from './managers/shield_information_barrier_segment_members.js';
+import { ShieldInformationBarrierSegmentRestrictionsManager } from './managers/shield_information_barrier_segment_restrictions.js';
+import { ShieldInformationBarrierSegmentsManager } from './managers/shield_information_barrier_segments.js';
+import { ShieldInformationBarriersManager } from './managers/shield_information_barriers.js';
+import { ShieldListsManager } from './managers/shield_lists.js';
+import { SignRequestsManager } from './managers/sign_requests.js';
+import { SignTemplatesManager } from './managers/sign_templates.js';
+import { SkillsManager } from './managers/skills.js';
+import { StoragePoliciesManager } from './managers/storage_policies.js';
+import { StoragePolicyAssignmentsManager } from './managers/storage_policy_assignments.js';
+import { TaskAssignmentsManager } from './managers/task_assignments.js';
+import { TasksManager } from './managers/tasks.js';
+import { TermsOfServiceUserStatusesManager } from './managers/terms_of_service_user_statuses.js';
+import { TermsOfServicesManager } from './managers/terms_of_services.js';
+import { TransferManager } from './managers/transfer.js';
+import { TrashedFilesManager } from './managers/trashed_files.js';
+import { TrashedFoldersManager } from './managers/trashed_folders.js';
+import { TrashedItemsManager } from './managers/trashed_items.js';
+import { TrashedWebLinksManager } from './managers/trashed_web_links.js';
+import { UploadsManager } from './managers/uploads.js';
+import { UserCollaborationsManager } from './managers/user_collaborations.js';
+import { UsersManager } from './managers/users.js';
+import { WebLinksManager } from './managers/web_links.js';
+import { WebhooksManager } from './managers/webhooks.js';
+import { WorkflowsManager } from './managers/workflows.js';
+import { ZipDownloadsManager } from './managers/zip_downloads.js';
+/** The Box SDK client: one manager per API area over a shared session. */
+export declare class Client {
+    readonly ai: AiManager;
+    readonly aiStudio: AiStudioManager;
+    readonly appItemAssociations: AppItemAssociationsManager;
+    readonly archives: ArchivesManager;
+    readonly authorization: AuthorizationManager;
+    readonly automateWorkflows: AutomateWorkflowsManager;
+    readonly avatars: AvatarsManager;
+    readonly chunkedUploads: ChunkedUploadsManager;
+    readonly classifications: ClassificationsManager;
+    readonly collaborationAllowlistEntries: CollaborationAllowlistEntriesManager;
+    readonly collaborationAllowlistExemptTargets: CollaborationAllowlistExemptTargetsManager;
+    readonly collections: CollectionsManager;
+    readonly comments: CommentsManager;
+    readonly devicePinners: DevicePinnersManager;
+    readonly docgen: DocgenManager;
+    readonly docgenTemplate: DocgenTemplateManager;
+    readonly downloads: DownloadsManager;
+    readonly emailAliases: EmailAliasesManager;
+    readonly enterpriseConfigurations: EnterpriseConfigurationsManager;
+    readonly events: EventsManager;
+    readonly externalUsers: ExternalUsersManager;
+    readonly fileClassifications: FileClassificationsManager;
+    readonly fileMetadata: FileMetadataManager;
+    readonly fileRequests: FileRequestsManager;
+    readonly fileVersionLegalHolds: FileVersionLegalHoldsManager;
+    readonly fileVersionRetentions: FileVersionRetentionsManager;
+    readonly fileVersions: FileVersionsManager;
+    readonly fileWatermarks: FileWatermarksManager;
+    readonly files: FilesManager;
+    readonly folderClassifications: FolderClassificationsManager;
+    readonly folderLocks: FolderLocksManager;
+    readonly folderMetadata: FolderMetadataManager;
+    readonly folderWatermarks: FolderWatermarksManager;
+    readonly folders: FoldersManager;
+    readonly groups: GroupsManager;
+    readonly hubCollaborations: HubCollaborationsManager;
+    readonly hubDocument: HubDocumentManager;
+    readonly hubItems: HubItemsManager;
+    readonly hubs: HubsManager;
+    readonly integrationMappings: IntegrationMappingsManager;
+    readonly invites: InvitesManager;
+    readonly legalHoldPolicies: LegalHoldPoliciesManager;
+    readonly legalHoldPolicyAssignments: LegalHoldPolicyAssignmentsManager;
+    readonly listCollaborations: ListCollaborationsManager;
+    readonly memberships: MembershipsManager;
+    readonly metadataCascadePolicies: MetadataCascadePoliciesManager;
+    readonly metadataTaxonomies: MetadataTaxonomiesManager;
+    readonly metadataTemplates: MetadataTemplatesManager;
+    readonly notes: NotesManager;
+    readonly recentItems: RecentItemsManager;
+    readonly retentionPolicies: RetentionPoliciesManager;
+    readonly retentionPolicyAssignments: RetentionPolicyAssignmentsManager;
+    readonly search: SearchManager;
+    readonly sessionTermination: SessionTerminationManager;
+    readonly sharedLinksAppItems: SharedLinksAppItemsManager;
+    readonly sharedLinksFiles: SharedLinksFilesManager;
+    readonly sharedLinksFolders: SharedLinksFoldersManager;
+    readonly sharedLinksWebLinks: SharedLinksWebLinksManager;
+    readonly shieldInformationBarrierReports: ShieldInformationBarrierReportsManager;
+    readonly shieldInformationBarrierSegmentMembers: ShieldInformationBarrierSegmentMembersManager;
+    readonly shieldInformationBarrierSegmentRestrictions: ShieldInformationBarrierSegmentRestrictionsManager;
+    readonly shieldInformationBarrierSegments: ShieldInformationBarrierSegmentsManager;
+    readonly shieldInformationBarriers: ShieldInformationBarriersManager;
+    readonly shieldLists: ShieldListsManager;
+    readonly signRequests: SignRequestsManager;
+    readonly signTemplates: SignTemplatesManager;
+    readonly skills: SkillsManager;
+    readonly storagePolicies: StoragePoliciesManager;
+    readonly storagePolicyAssignments: StoragePolicyAssignmentsManager;
+    readonly taskAssignments: TaskAssignmentsManager;
+    readonly tasks: TasksManager;
+    readonly termsOfServiceUserStatuses: TermsOfServiceUserStatusesManager;
+    readonly termsOfServices: TermsOfServicesManager;
+    readonly transfer: TransferManager;
+    readonly trashedFiles: TrashedFilesManager;
+    readonly trashedFolders: TrashedFoldersManager;
+    readonly trashedItems: TrashedItemsManager;
+    readonly trashedWebLinks: TrashedWebLinksManager;
+    readonly uploads: UploadsManager;
+    readonly userCollaborations: UserCollaborationsManager;
+    readonly users: UsersManager;
+    readonly webLinks: WebLinksManager;
+    readonly webhooks: WebhooksManager;
+    readonly workflows: WorkflowsManager;
+    readonly zipDownloads: ZipDownloadsManager;
+    /** Build a client for an authentication flow. */
+    constructor(auth: Auth);
+}

package/dist/types/errors.d.ts

@@ -0,0 +1,19 @@
+/** Options for a `BoxApiError`. */
+export interface BoxApiErrorOptions {
+    /** The HTTP status, when the error carries a response. */
+    status?: number;
+    /** The underlying failure (a transport error, a decode error), preserved for
+     * diagnostics. */
+    cause?: unknown;
+}
+/**
+ * A runtime error: a failed request, auth acquisition, or body decode. The
+ * generated SDK's exceptions model (TR-TS.3) surfaces every failure as a thrown
+ * `BoxApiError` — the TypeScript analogue of Go's `error` return and Rust's
+ * `Result::Err`.
+ */
+export declare class BoxApiError extends Error {
+    /** The HTTP status, when the error carries a response. */
+    readonly status?: number;
+    constructor(message: string, options?: BoxApiErrorOptions);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { Client } from './client.js';
+export * as models from './models/index.js';
+export * as managers from './managers/index.js';
+export * as runtime from './runtime.js';
+export * as buildinfo from './buildinfo.js';

package/dist/types/internal.d.ts

@@ -0,0 +1,9 @@
+/** Comma-join a list into a query value, converting each element with `f`. */
+export declare function join<T>(items: Array<T>, f: (v: T) => string): string;
+/** Percent-encode a value, leaving RFC 3986 unreserved characters as-is. */
+export declare function pathEscape(value: string): string;
+/**
+ * An application/x-www-form-urlencoded body from key/value pairs (the OAuth2
+ * token endpoints): each key and value percent-encoded, joined by `&`.
+ */
+export declare function formEncode(pairs: Array<[string, string]>): string;

package/dist/types/jwt.d.ts

@@ -0,0 +1,23 @@
+import { type Auth } from './tokens.js';
+/**
+ * JWT server auth with a signing key (Box's `box_config.json` fields).
+ * `privateKeyPem` is the RSA private key, optionally encrypted with
+ * `passphrase`. Set exactly one subject — `enterpriseId` or `userId`.
+ */
+export interface JwtConfig {
+    clientId: string;
+    clientSecret: string;
+    publicKeyId: string;
+    privateKeyPem: string;
+    passphrase?: string;
+    enterpriseId?: string;
+    userId?: string;
+    /** Optional; defaults to Box's token endpoint. */
+    tokenUrl?: string;
+}
+/**
+ * Build a JWT-assertion `Auth`, parsing (and if needed decrypting) the RSA
+ * private key up front so a bad key fails loudly here rather than on the first
+ * request. Returns a promise because it imports `node:crypto` on demand.
+ */
+export declare function jwtAuth(config: JwtConfig): Promise<Auth>;

package/dist/types/managers/ai.d.ts

@@ -0,0 +1,17 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for AiManager.getAgentDefault. */
+export interface AiManagerGetAgentDefaultOptions {
+    language?: string;
+    model?: string;
+}
+/** Operations for the "ai" API area. */
+export declare class AiManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    ask(body: models.schemas.AiAsk): Promise<models.schemas.AiResponseFull>;
+    createTextGen(body: models.schemas.AiTextGen): Promise<models.schemas.AiResponse>;
+    getAgentDefault(mode: models.schemas.GetAgentDefaultMode, opts?: AiManagerGetAgentDefaultOptions): Promise<models.schemas.AiAgent>;
+    extract(body: models.schemas.AiExtract): Promise<models.schemas.AiResponse>;
+    createExtractStructured(body: models.schemas.AiExtractStructured): Promise<models.schemas.AiExtractStructuredResponse>;
+}

package/dist/types/managers/ai_studio.d.ts

@@ -0,0 +1,27 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for AiStudioManager.listAiAgents. */
+export interface AiStudioManagerListAiAgentsOptions {
+    mode?: Array<string>;
+    fields?: Array<string>;
+    agent_state?: Array<string>;
+    include_box_default?: boolean;
+    marker?: string;
+    limit?: number;
+}
+/** Optional parameters for AiStudioManager.getAiAgent. */
+export interface AiStudioManagerGetAiAgentOptions {
+    fields?: Array<string>;
+}
+/** Operations for the "ai_studio" API area. */
+export declare class AiStudioManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    /** Iterate every `models.schemas.AiSingleAgentResponseFull` across pages, threading the marker cursor. */
+    listAiAgents(opts?: AiStudioManagerListAiAgentsOptions): AsyncIterableIterator<models.schemas.AiSingleAgentResponseFull>;
+    private listAiAgentsPage;
+    createAiAgents(body: models.schemas.CreateAiAgent): Promise<models.schemas.AiSingleAgentResponseFull>;
+    getAiAgent(agentId: string, opts?: AiStudioManagerGetAiAgentOptions): Promise<models.schemas.AiSingleAgentResponseFull>;
+    updateAiAgent(agentId: string, body: models.schemas.CreateAiAgent): Promise<models.schemas.AiSingleAgentResponseFull>;
+    deleteAiAgent(agentId: string): Promise<void>;
+}

package/dist/types/managers/app_item_associations.d.ts

@@ -0,0 +1,25 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for AppItemAssociationsManager.listFile. */
+export interface AppItemAssociationsManagerListFileOptions {
+    limit?: number;
+    marker?: string;
+    application_type?: string;
+}
+/** Optional parameters for AppItemAssociationsManager.listFolder. */
+export interface AppItemAssociationsManagerListFolderOptions {
+    limit?: number;
+    marker?: string;
+    application_type?: string;
+}
+/** Operations for the "app_item_associations" API area. */
+export declare class AppItemAssociationsManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    /** Iterate every `models.schemas.AppItemAssociation` across pages, threading the marker cursor. */
+    listFile(fileId: string, opts?: AppItemAssociationsManagerListFileOptions): AsyncIterableIterator<models.schemas.AppItemAssociation>;
+    private listFilePage;
+    /** Iterate every `models.schemas.AppItemAssociation` across pages, threading the marker cursor. */
+    listFolder(folderId: string, opts?: AppItemAssociationsManagerListFolderOptions): AsyncIterableIterator<models.schemas.AppItemAssociation>;
+    private listFolderPage;
+}

package/dist/types/managers/archives.d.ts

@@ -0,0 +1,18 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for ArchivesManager.list. */
+export interface ArchivesManagerListOptions {
+    limit?: number;
+    marker?: string;
+}
+/** Operations for the "archives" API area. */
+export declare class ArchivesManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    /** Iterate every `models.schemas.Archive` across pages, threading the marker cursor. */
+    list(opts?: ArchivesManagerListOptions): AsyncIterableIterator<models.schemas.Archive>;
+    private listPage;
+    create(body: models.schemas.ArchiveCreateRequest): Promise<models.schemas.Archive>;
+    update(archiveId: string, body: models.schemas.ArchiveUpdateRequest): Promise<models.schemas.Archive>;
+    delete_(archiveId: string): Promise<void>;
+}

package/dist/types/managers/authorization.d.ts

@@ -0,0 +1,17 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for AuthorizationManager.authorize. */
+export interface AuthorizationManagerAuthorizeOptions {
+    redirect_uri?: string;
+    state?: string;
+    scope?: string;
+}
+/** Operations for the "authorization" API area. */
+export declare class AuthorizationManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    authorize(responseType: models.schemas.GetAuthorizeResponseType, clientId: string, opts?: AuthorizationManagerAuthorizeOptions): Promise<string>;
+    createOauth2Token(body: models.schemas.PostOAuth2Token): Promise<models.schemas.AccessToken>;
+    createOauth2TokenRefresh(body: models.schemas.PostOAuth2TokenRefreshAccessToken): Promise<models.schemas.AccessToken>;
+    revokeOauth2(body: models.schemas.PostOAuth2Revoke): Promise<void>;
+}

package/dist/types/managers/automate_workflows.d.ts

@@ -0,0 +1,16 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for AutomateWorkflowsManager.list. */
+export interface AutomateWorkflowsManagerListOptions {
+    limit?: number;
+    marker?: string;
+}
+/** Operations for the "automate_workflows" API area. */
+export declare class AutomateWorkflowsManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    /** Iterate every `models.schemas.AutomateWorkflowAction` across pages, threading the marker cursor. */
+    list(folderId: string, opts?: AutomateWorkflowsManagerListOptions): AsyncIterableIterator<models.schemas.AutomateWorkflowAction>;
+    private listPage;
+    start(workflowId: string, body: models.schemas.AutomateWorkflowStartRequest): Promise<void>;
+}

package/dist/types/managers/avatars.d.ts

@@ -0,0 +1,10 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Operations for the "avatars" API area. */
+export declare class AvatarsManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    getUserAvatar(userId: string): Promise<runtime.Stream>;
+    createUserAvatar(userId: string, body: models.schemas.UserAvatarCreateRequest): Promise<models.schemas.UserAvatar>;
+    deleteUserAvatar(userId: string): Promise<void>;
+}

package/dist/types/managers/chunked_uploads.d.ts

@@ -0,0 +1,26 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for ChunkedUploadsManager.listFileUploadSessionParts. */
+export interface ChunkedUploadsManagerListFileUploadSessionPartsOptions {
+    offset?: number;
+    limit?: number;
+}
+/** Optional parameters for ChunkedUploadsManager.commitFileUploadSession. */
+export interface ChunkedUploadsManagerCommitFileUploadSessionOptions {
+    "if-match"?: string;
+    "if-none-match"?: string;
+}
+/** Operations for the "chunked_uploads" API area. */
+export declare class ChunkedUploadsManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    createFileUploadSessions(body: models.schemas.FileUploadSessionsCreateRequest): Promise<models.schemas.UploadSession>;
+    createFileByIdUploadSessions(fileId: string, body: models.schemas.FileIdUploadSessionsCreateRequest): Promise<models.schemas.UploadSession>;
+    getFileUploadSession(uploadSessionId: string): Promise<models.schemas.UploadSession>;
+    updateFileUploadSession(uploadSessionId: string, digest: string, contentRange: string, body: Blob): Promise<models.schemas.UploadedPart>;
+    deleteFileUploadSession(uploadSessionId: string): Promise<void>;
+    /** Iterate every `models.schemas.UploadPart` across pages, threading the offset cursor. */
+    listFileUploadSessionParts(uploadSessionId: string, opts?: ChunkedUploadsManagerListFileUploadSessionPartsOptions): AsyncIterableIterator<models.schemas.UploadPart>;
+    private listFileUploadSessionPartsPage;
+    commitFileUploadSession(uploadSessionId: string, digest: string, body: models.schemas.FileUploadSessionCommitRequest, opts?: ChunkedUploadsManagerCommitFileUploadSessionOptions): Promise<models.schemas.Files>;
+}

package/dist/types/managers/classifications.d.ts

@@ -0,0 +1,11 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Operations for the "classifications" API area. */
+export declare class ClassificationsManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    get(): Promise<models.schemas.ClassificationTemplate>;
+    updateAdd(body: Array<models.schemas.ClassificationUpdateRequest>): Promise<models.schemas.ClassificationTemplate>;
+    updateUpdate(body: Array<models.schemas.ClassificationUpdateRequest2>): Promise<models.schemas.ClassificationTemplate>;
+    createMetadataTemplateSchemaClassifications(body: models.schemas.MetadataTemplateSchemaCreateRequest): Promise<models.schemas.ClassificationTemplate>;
+}

package/dist/types/managers/collaboration_allowlist_entries.d.ts

@@ -0,0 +1,18 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for CollaborationAllowlistEntriesManager.listCollaborationWhitelistEntries. */
+export interface CollaborationAllowlistEntriesManagerListCollaborationWhitelistEntriesOptions {
+    marker?: string;
+    limit?: number;
+}
+/** Operations for the "collaboration_allowlist_entries" API area. */
+export declare class CollaborationAllowlistEntriesManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    /** Iterate every `models.schemas.CollaborationAllowlistEntry` across pages, threading the marker cursor. */
+    listCollaborationWhitelistEntries(opts?: CollaborationAllowlistEntriesManagerListCollaborationWhitelistEntriesOptions): AsyncIterableIterator<models.schemas.CollaborationAllowlistEntry>;
+    private listCollaborationWhitelistEntriesPage;
+    createCollaborationWhitelistEntries(body: models.schemas.CollaborationWhitelistEntriesCreateRequest): Promise<models.schemas.CollaborationAllowlistEntry>;
+    getCollaborationWhitelistEntry(collaborationWhitelistEntryId: string): Promise<models.schemas.CollaborationAllowlistEntry>;
+    deleteCollaborationWhitelistEntry(collaborationWhitelistEntryId: string): Promise<void>;
+}

package/dist/types/managers/collaboration_allowlist_exempt_targets.d.ts

@@ -0,0 +1,18 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Optional parameters for CollaborationAllowlistExemptTargetsManager.listCollaborationWhitelistExemptTargets. */
+export interface CollaborationAllowlistExemptTargetsManagerListCollaborationWhitelistExemptTargetsOptions {
+    marker?: string;
+    limit?: number;
+}
+/** Operations for the "collaboration_allowlist_exempt_targets" API area. */
+export declare class CollaborationAllowlistExemptTargetsManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    /** Iterate every `models.schemas.CollaborationAllowlistExemptTarget` across pages, threading the marker cursor. */
+    listCollaborationWhitelistExemptTargets(opts?: CollaborationAllowlistExemptTargetsManagerListCollaborationWhitelistExemptTargetsOptions): AsyncIterableIterator<models.schemas.CollaborationAllowlistExemptTarget>;
+    private listCollaborationWhitelistExemptTargetsPage;
+    createCollaborationWhitelistExemptTargets(body: models.schemas.CollaborationWhitelistExemptTargetsCreateRequest): Promise<models.schemas.CollaborationAllowlistExemptTarget>;
+    getCollaborationWhitelistExemptTarget(collaborationWhitelistExemptTargetId: string): Promise<models.schemas.CollaborationAllowlistExemptTarget>;
+    deleteCollaborationWhitelistExemptTarget(collaborationWhitelistExemptTargetId: string): Promise<void>;
+}