@andesine/sdk 0.1.0 → 0.4.0

package/dist/index-moj3WP71.d.ts

@@ -0,0 +1,1982 @@
+import { $ as InvitePendingErrorData, $t as TextPropertyFilter, A as ContentNodeInput, At as ResolvedSchemaField, B as EntryPropertyKind, Bt as SchemaFragment, C as Collection, Ct as PublishedVersion, D as ContentMarkInput, Dt as PublishingSnapshotErrorData, E as ContentMark, Et as PublishingChannelListItem, F as DatePropertyFilter, Ft as SchemaDefinition, G as EntryVersion, Gt as SchemaProperty, H as EntryPublication, Ht as SchemaMigrationContentLossEntry, I as EffectiveCollectionSchema, It as SchemaDraftDefinition, J as ForbiddenErrorData, Jt as SchemaVersion, K as EntryVersionSummary, Kt as SchemaPropertyValue, L as Entry, Lt as SchemaField, M as ContentSchemaIssue, Mt as Role, N as ContentSchemaMetadata, Nt as SchemaApplicationResult, O as ContentNameConflictErrorData, Ot as RateLimitErrorData, P as ContentSchemaMismatchErrorData, Pt as SchemaBlockType, Q as InviteDeliveryResult, Qt as SearchResults, R as EntryFragment, Rt as SchemaFieldKeyConflictErrorData, S as ChannelContentStatus, St as PublishedTree, T as ComparisonOperator, Tt as PublishingChannelCode, U as EntryPublicationChannel, Ut as SchemaMigrationErrorData, V as EntryPropertyValue, Vt as SchemaMigration, W as EntrySummary, Wt as SchemaMigrationStatus, X as InstanceInfo, Xt as SearchPropertyValue, Y as Identity, Yt as SchemaVersionSummary, Z as Invite, Zt as SearchResult, _ as BaseRole, _n as operations, _t as PublishedEntriesResult, a as Asset, an as UserProfile, at as NumberPropertyFilter, b as ChannelContentCollection, bt as PublishedEntrySummary, c as AssetConflictErrorData, cn as VersionReason, ct as PropertyFilter, d as AssetSearchResult, dn as WebhookEndpoint, dt as PublishedAnswerEvent, en as TypeMetadata, et as InviteStatus, f as AssetStatus, fn as WebhookEvent, ft as PublishedAnswerSource, g as AssetVariant, gn as components, gt as PublishedContent, h as AssetValidationErrorData, hn as WorkspaceListItem, ht as PublishedCollectionSummary, i as AnswerSource, in as UnpublishedEntriesResult, it as MembershipInviteResult, j as ContentSchemaInvalidErrorData, jt as RevertPublishingChangesResult, k as ContentNode, kt as ResolvedSchemaDefinition, l as AssetFile, ln as WebhookAttempt, lt as PublishEntryTarget, m as AssetUploadRegistration, mn as WebhookRun, mt as PublishedCollection, n as AnswerEvent, nn as TypeMetadataEntry, nt as Membership, o as AssetAnalysis, on as ValidationErrorData, ot as Pagination, p as AssetStorageErrorData, pn as WebhookEventName, pt as PublishedAsset, q as ErrorData, qt as SchemaRevision, r as AnswerHistoryMessage, rn as TypeMetadataTree, rt as MembershipExistsErrorData, s as AssetAnalysisStatus, sn as ValidationIssue, st as Permission, t as Answer, tn as TypeMetadataCollection, tt as LocalCollectionSchema, u as AssetFileFormat, un as WebhookDelivery, ut as PublishedAnswer, v as BooleanPropertyFilter, vt as PublishedEntry, w as CollectionSchema, wt as PublishingChannel, x as ChannelContentEntry, xt as PublishedSearchResult, y as ChannelContent, yt as PublishedEntryContent, z as EntryProperty, zt as SchemaFieldSource } from "./schema-BcVop8NH.js";
+//#region src/workspace.d.ts
+/**
+ * Type-only description of one workspace and content source.
+ * It does not select a workspace, bind a snapshot, or validate a server response.
+ * Generated collection/entry keys can include IDs, canonical paths, and slug paths. Unknown keys retain general SDK types.
+ */
+interface WorkspaceTypeMap {
+  workspaceID?: string;
+  source: {
+    kind: "current" | "published";
+    channel?: string;
+    snapshotID?: string;
+  };
+  collections: Readonly<Record<string, WorkspaceCollection>>;
+  schemas: Readonly<Record<string, WorkspaceSchema>>;
+  /** Optional exact entry bindings. Omit ID or name/slug path keys when their generation is disabled. */
+  entries?: Readonly<Record<string, WorkspaceEntry>>;
+  /** Optional published trees keyed by collection selector. Does not affect current reads. */
+  tree?: Readonly<Record<string, PublishedCollection>>;
+}
+/** One collection's content variants and known descendant collection selectors. */
+interface WorkspaceCollection {
+  id: string | null;
+  path: string;
+  slugPath: string;
+  /** Exact recorded revision IDs; null is schema-free content. An empty tuple uses general content. */
+  schemaRevisionIDs: ReadonlyArray<string | null>;
+  /** All descendants, not only direct children. Omit when unknown; use [] for a known leaf. */
+  descendants?: readonly string[];
+}
+/** Effective fields for one recorded schema revision, including inherited fields. */
+interface WorkspaceSchema {
+  hash: string;
+  properties: Readonly<Record<string, EntryProperty | undefined>>;
+  fragments: Readonly<Record<string, EntryFragment | undefined>>;
+}
+/** An exact entry binding; its revision can be narrower than its collection's revision union. */
+interface WorkspaceEntry {
+  collection: string;
+  schemaRevisionID: string | null;
+}
+interface ContentShape {
+  schema: ContentSchemaMetadata | null;
+  properties: Readonly<Record<string, EntryProperty | undefined>>;
+  fragments: Readonly<Record<string, EntryFragment | undefined>>;
+}
+type GeneralContent = Pick<PublishedEntryContent, "schema" | "properties" | "fragments">;
+/** Content fields for named revision types. Preserves revision unions and schema-free branches. */
+type SchemaContent<Workspace extends WorkspaceTypeMap, RevisionID extends string | null> = [RevisionID] extends [never] ? GeneralContent : RevisionID extends null ? GeneralContent & {
+  schema: null;
+} : RevisionID extends keyof Workspace["schemas"] ? {
+  schema: {
+    revisionID: RevisionID;
+    hash: Workspace["schemas"][RevisionID]["hash"];
+  };
+  properties: Workspace["schemas"][RevisionID]["properties"];
+  fragments: Workspace["schemas"][RevisionID]["fragments"];
+} : GeneralContent;
+//#endregion
+//#region src/workspace-output.d.ts
+type Lookup<Map, Key> = Key extends string ? string extends Key ? undefined : Key extends keyof Map ? Map[Key] : undefined : undefined;
+type Selector$1<Input, Keys extends string> = Input extends unknown ? [Extract<Keys, keyof Input>] extends [never] ? undefined : Input[Extract<Keys, keyof Input>] : never;
+type EntryMap<Workspace> = Workspace extends {
+  entries: infer Entries;
+} ? Entries : Record<never, never>;
+type TreeMap<Workspace> = Workspace extends {
+  tree: infer Tree;
+} ? Tree : Record<never, never>;
+type ApplyContent<Base, Shape> = Shape extends ContentShape ? Omit<Base, keyof ContentShape> & Shape : Base;
+type CollectionIdentity<Collection> = Collection extends WorkspaceCollection ? {
+  collectionID: Collection["id"];
+} : Record<never, never>;
+type EntryContent<Base, Workspace extends WorkspaceTypeMap, Binding> = Binding extends WorkspaceEntry ? ApplyContent<Base, SchemaContent<Workspace, Binding["schemaRevisionID"]>> & (Workspace["source"] extends {
+  kind: "published";
+} ? CollectionIdentity<Lookup<Workspace["collections"], Binding["collection"]>> : Record<never, never>) : Base;
+type EntryOutput<Base, Workspace extends WorkspaceTypeMap, Input, ID extends string> = EntryContent<Base, Workspace, Lookup<EntryMap<Workspace>, Selector$1<Input, ID | "path" | "slugPath">>>;
+type Descendants<Workspace extends WorkspaceTypeMap, Collection> = Collection extends {
+  descendants: readonly string[];
+} ? Lookup<Workspace["collections"], Collection["descendants"][number]> : undefined;
+type ListCollections<Workspace extends WorkspaceTypeMap, Input, Collection> = "descendants" extends keyof Input ? Input extends {
+  descendants?: false | undefined;
+} ? Collection : Collection | Descendants<Workspace, Collection> : Collection;
+type CollectionContent<Base, Workspace extends WorkspaceTypeMap, Collection> = Collection extends WorkspaceCollection ? ApplyContent<Base, SchemaContent<Workspace, Collection["schemaRevisionIDs"][number]>> & {
+  collectionID: Collection["id"];
+} : Base;
+/** Apply known collection shapes only to published list content; summaries stay unchanged. */
+type WorkspaceListContent<Base, Workspace extends WorkspaceTypeMap, Input> = Workspace["source"] extends {
+  kind: "published";
+} ? CollectionContent<Base, Workspace, ListCollections<Workspace, Input, Lookup<Workspace["collections"], Selector$1<Input, "collectionID" | "collectionPath" | "collectionSlugPath">>>> : Base;
+type TreeOutput<Base, Tree> = Tree extends PublishedCollection ? Omit<Base, "collection"> & {
+  collection: Tree;
+} : Base;
+type SchemaOutput<Base, Shape> = Shape extends {
+  schema: infer Schema;
+} ? Schema extends null ? null : Omit<NonNullable<Base>, "revisionID" | "hash"> & Schema : Base;
+type EntrySchemaOutput<Base, Workspace extends WorkspaceTypeMap, Binding> = Binding extends WorkspaceEntry ? SchemaOutput<Base, SchemaContent<Workspace, Binding["schemaRevisionID"]>> : Base;
+/** Specialize reads for their matching source; unrelated operations retain their generated types. */
+type WorkspaceOperationOutput<Operation extends string, Base, Workspace extends WorkspaceTypeMap, Input> = Operation extends "entries.get" ? Workspace["source"] extends {
+  kind: "current";
+} ? EntryOutput<Base, Workspace, Input, "id"> : Base : Workspace["source"] extends {
+  kind: "published";
+} ? Operation extends "content.get" ? EntryOutput<Base, Workspace, Input, "entryID"> : Operation extends "content.getSchema" ? EntrySchemaOutput<Base, Workspace, Lookup<EntryMap<Workspace>, Selector$1<Input, "entryID" | "path" | "slugPath">>> : Operation extends "content.getTree" ? TreeOutput<Base, Lookup<TreeMap<Workspace>, Selector$1<Input, "collectionID" | "collectionPath" | "collectionSlugPath">>> : Base : Base;
+//#endregion
+//#region src/content-list.d.ts
+interface ContentListOperation<Workspace extends WorkspaceTypeMap = WorkspaceTypeMap> {
+  <const Input extends OperationInput<"content.listEntries"> = Record<string, never>>(input: Input, options: RequestOptions & {
+    response: "full";
+  }): Promise<APIResponse<ContentListOutput<Input, Workspace>> | NotModifiedResponse>;
+  <const Input extends OperationInput<"content.listEntries"> = Record<string, never>>(input?: Input, options?: RequestOptions & {
+    response?: "data";
+  }): Promise<ContentListOutput<Input, Workspace>>;
+}
+type FullContent<Input, Workspace extends WorkspaceTypeMap> = WorkspaceListContent<components["schemas"]["PublishedEntryContent"], Workspace, Input>;
+type ContentListOutput<Input, Workspace extends WorkspaceTypeMap = WorkspaceTypeMap> = Omit<RawOperationOutput<"content.listEntries">, "data"> & {
+  data: Array<Input extends {
+    includeContent: true;
+  } ? FullContent<Input, Workspace> : "includeContent" extends keyof Input ? Input extends {
+    includeContent?: false | undefined;
+  } ? components["schemas"]["PublishedEntrySummary"] : FullContent<Input, Workspace> | components["schemas"]["PublishedEntrySummary"] : components["schemas"]["PublishedEntrySummary"]>;
+};
+//#endregion
+//#region src/selectors.d.ts
+type SelectorValue<T, Key extends string> = Key extends keyof T ? NonNullable<T[Key]> : never;
+type SelectorBranch<T, Keys extends string, Key extends Keys = Keys> = Key extends Keys ? { [Selected in Key]: SelectorValue<T, Selected>; } & { [Other in Exclude<Keys, Key>]?: never; } : never;
+type Selector<T, Keys extends string, Optional extends boolean = false> = T & (SelectorBranch<T, Keys> | (Optional extends true ? { [Key in Keys]?: never; } : never));
+type WithSelectors<Operation extends string, Input> = Operation extends "entries.get" ? Selector<Input, "id" | "path" | "slugPath"> : Operation extends "content.get" | "content.getSchema" ? Selector<Input, "entryID" | "path" | "slugPath"> : "collectionPath" extends keyof Input ? Selector<Input, "collectionID" | "collectionPath" | "collectionSlugPath", Operation extends "content.getTree" | "schemas.get" ? false : true> : Input;
+//#endregion
+//#region src/operation.d.ts
+interface RequestOptions {
+  /** Cancel the request or stream, preserving the signal's abort reason. */
+  signal?: AbortSignal;
+  /** Override the client timeout in milliseconds; 0 disables it. Includes stream consumption. */
+  timeout?: number;
+  /** Override GET retry attempts. Defaults to the client setting; other methods never retry. */
+  retries?: number;
+  /** Headers merged over client headers. The configured credential supplies Authorization. */
+  headers?: HeadersInit;
+  /** Return data by default, or status/headers/data with "full". Required for possible 304s. */
+  response?: "data" | "full";
+}
+interface APIResponse<T> {
+  status: number;
+  headers: Headers;
+  data: T;
+  notModified: false;
+}
+interface NotModifiedResponse {
+  status: 304;
+  headers: Headers;
+  data: undefined;
+  notModified: true;
+}
+interface StandardOperation<K extends keyof operations, Workspace extends WorkspaceTypeMap> {
+  <const Input extends OperationInput<K>>(input: Input, options: RequestOptions & {
+    response: "full";
+  }): Promise<APIResponse<OperationOutput<K, Workspace, Input>> | NotModifiedResponse>;
+  <const Input extends OperationInput<K> = OperationInput<K>>(...args: Record<string, never> extends OperationInput<K> ? [input?: Input, options?: RequestOptions & {
+    response?: "data";
+  }] : [input: Input, options?: RequestOptions & {
+    response?: "data";
+  }]): Promise<OperationOutput<K, Workspace, Input>>;
+}
+interface StreamOperation<K extends keyof operations> {
+  (input: OperationInput<K>, options: RequestOptions & {
+    response: "full";
+  }): Promise<APIResponse<OperationOutput<K>>>;
+  (input: OperationInput<K>, options?: RequestOptions & {
+    response?: "data";
+  }): Promise<OperationOutput<K>>;
+}
+type StreamContent<K extends keyof operations> = Responses<K>[Extract<keyof Responses<K>, 200>] extends {
+  content: {
+    "text/event-stream": infer Frames;
+  };
+} ? Frames : never;
+type StreamEvent<K extends keyof operations> = Extract<StreamContent<K>, {
+  event: "message";
+}> extends {
+  data: infer Event;
+} ? Event : never;
+type Operation<K extends keyof operations, Workspace extends WorkspaceTypeMap = WorkspaceTypeMap> = [StreamContent<K>] extends [never] ? K extends "content.listEntries" ? ContentListOperation<Workspace> : StandardOperation<K, Workspace> : StreamOperation<K>;
+type Content<T> = T extends {
+  content: infer C;
+} ? C[keyof C] : never;
+type Parameters<T, K extends string> = T extends {
+  parameters: infer P;
+} ? K extends keyof P ? [NonNullable<P[K]>] extends [never] ? unknown : NonNullable<P[K]> : unknown : unknown;
+type Body<T> = T extends {
+  requestBody?: infer B;
+} ? [Content<NonNullable<B>>] extends [never] ? unknown : Content<NonNullable<B>> : unknown;
+type OperationInput<K extends keyof operations> = WithSelectors<K, Parameters<operations[K], "path"> & Parameters<operations[K], "query"> & Body<operations[K]>>;
+type Responses<K extends keyof operations> = operations[K]["responses"];
+type SuccessContent<K extends keyof operations> = Content<Responses<K>[Extract<keyof Responses<K>, 200 | 201 | 202 | 203 | 206>]>;
+type OperationError<K extends keyof operations> = K extends keyof operations ? Extract<Content<Responses<K>[keyof Responses<K>]>, {
+  defined: true;
+  code: string;
+}> : never;
+type APIErrorBody = OperationError<keyof operations>;
+type APIErrorCode = APIErrorBody["code"];
+type APIErrorData<C extends APIErrorCode> = Extract<APIErrorBody, {
+  code: C;
+}>["data"];
+type RawOperationOutput<K extends keyof operations> = [StreamContent<K>] extends [never] ? [SuccessContent<K>] extends [never] ? void : SuccessContent<K> : AsyncIterableIterator<StreamEvent<K>>;
+type OperationOutput<K extends keyof operations, Workspace extends WorkspaceTypeMap = WorkspaceTypeMap, Input = OperationInput<K>> = K extends "content.listEntries" ? ContentListOutput<Input, Workspace> : WorkspaceOperationOutput<K, RawOperationOutput<K>, Workspace, Input>;
+//#endregion
+//#region src/generated/resources.d.ts
+interface APIResources<Workspace extends WorkspaceTypeMap = WorkspaceTypeMap> {
+  assets: {
+    /**
+     * Search assets
+     *
+     * Finds workspace images by text or SHA-256 checksum. Semantic search defaults to true and uses 1 AI credit for a text query. Returns up to 50 results.
+     *
+     * Required API key permissions: read:entries, read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.assets.search({
+     *   "query": "mountains",
+     *   "limit": 10
+     * });
+     */
+    search: Operation<"assets.search", Workspace>;
+    /**
+     * Import an image URL
+     *
+     * Downloads a remote image and starts processing it for the entry. With checkDuplicates, can return an existing image instead. Use assets.get to check processing status.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.assets.importURL({
+     *   "assetID": "ast_example",
+     *   "entryID": "ent_example",
+     *   "url": "https://example.com/image.png",
+     *   "checkDuplicates": true
+     * });
+     */
+    importURL: Operation<"assets.importURL", Workspace>;
+    /**
+     * Attach an asset
+     *
+     * Attaches a ready image to an entry. This does not insert an image node into the document.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.assets.attach({
+     *   "assetID": "ast_example",
+     *   "entryID": "ent_example"
+     * });
+     */
+    attach: Operation<"assets.attach", Workspace>;
+    /**
+     * Register an image upload
+     *
+     * Reserves an image upload for an entry. Supply the byte count and lowercase SHA-256 checksum of the file. Call assets.upload before expiresAt, then use assets.get to check processing status.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.assets.register({
+     *   "assetID": "ast_example",
+     *   "entryID": "ent_example",
+     *   "filename": "image.png",
+     *   "byteSize": 1024,
+     *   "checksum": "0000000000000000000000000000000000000000000000000000000000000000"
+     * });
+     */
+    register: Operation<"assets.register", Workspace>;
+    /**
+     * Upload registered image bytes
+     *
+     * Uploads a file for a registered asset with multipart/form-data. The bytes must match the registered size and checksum. Processing continues after the upload; use assets.get to check status.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.assets.upload({
+     *   "assetID": "ast_example",
+     *   "file": new Blob([imageBytes], { type: "image/png" })
+     * });
+     */
+    upload: Operation<"assets.upload", Workspace>;
+    /**
+     * Get asset status and details
+     *
+     * Returns image metadata, processing status, and available files. Supply entryID when checking access through an entry.
+     *
+     * @example
+     * await client.assets.get({
+     *   "assetID": "ast_example",
+     *   "entryID": "ent_example"
+     * });
+     */
+    get: Operation<"assets.get", Workspace>;
+  };
+  auth: {
+    /**
+     * Get credential identity
+     *
+     * Returns the authenticated user for OAuth or browser credentials, or the key and workspace IDs for an API key. Does not require a workspace selection and does not count toward API usage.
+     */
+    getIdentity: Operation<"auth.getIdentity", Workspace>;
+  };
+  instance: {
+    /**
+     * Get instance capabilities and limits
+     *
+     * Returns configured features and effective limits for the authenticated workspace. These values do not grant permissions or report live service health. No discovery request is made automatically by the SDK.
+     *
+     * @example
+     * await client.instance.get({});
+     */
+    get: Operation<"instance.get", Workspace>;
+  };
+  entries: {
+    /**
+     * Create an entry
+     *
+     * Creates an entry and its initial document. The name defaults to Untitled. Creation selects an available sibling name with a numeric suffix when needed. Names are trimmed and NFC-normalized. Derived URL slugs must be unique across sibling entries and collections, including case and punctuation variants. Names cannot contain a slash or equal a single dot or two dots. A collection schema can set the initial content.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.entries.create({
+     *   "name": "Getting started",
+     *   "collectionID": "coll_example"
+     * });
+     */
+    create: Operation<"entries.create", Workspace>;
+    /**
+     * Delete entries
+     *
+     * Soft-deletes the selected entries and clears current-entry selections for affected members. An active schema migration can block this action.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.entries.bulkDelete({
+     *   "ids": [
+     *     "ent_example"
+     *   ]
+     * });
+     */
+    bulkDelete: Operation<"entries.bulkDelete", Workspace>;
+    /**
+     * Delete an entry
+     *
+     * Soft-deletes the entry and clears current-entry selections for affected members. An active schema migration can block this action.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.entries.delete({
+     *   "id": "ent_example"
+     * });
+     */
+    delete: Operation<"entries.delete", Workspace>;
+    /**
+     * Rename an entry
+     *
+     * Updates the entry name. Rejects names already used by a sibling entry or collection. An active schema migration can block this action.
+     *
+     * Required API key permissions: entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.entries.update({
+     *   "id": "ent_example",
+     *   "name": "Installation"
+     * });
+     */
+    update: Operation<"entries.update", Workspace>;
+    /**
+     * Get an entry
+     *
+     * Returns current entry details, fragments, properties, and recorded schema metadata. Validates content without changing it. expectedSchemaHash must match the recorded schema; schema-less content cannot match it. Use content.get to read published content.
+     *
+     * Required API key permissions: read:entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.entries.get({
+     *   "id": "ent_example"
+     * });
+     */
+    get: Operation<"entries.get", Workspace>;
+    /**
+     * List entries
+     *
+     * Lists entries in the selected collection, or all accessible entries when collectionID is omitted. Pass pagination.nextCursor to the next request while pagination.hasMore is true. The limit is 1 to 100 and defaults to 50.
+     *
+     * Required API key permissions: read:entries. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.entries.list({
+     *   "collectionID": "coll_example",
+     *   "limit": 20
+     * });
+     */
+    list: Operation<"entries.list", Workspace>;
+  };
+  collections: {
+    /**
+     * Create a collection
+     *
+     * Creates a child collection. Without parentID, uses the workspace root. The name defaults to Untitled. Creation selects an available sibling name with a numeric suffix when needed. Names are trimmed and NFC-normalized. Derived URL slugs must be unique across sibling entries and collections, including case and punctuation variants. Names cannot contain a slash or equal a single dot or two dots. Restricted collections require a session with restricted_collections permission and the Pro plan; API keys cannot create them.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.collections.create({
+     *   "name": "Documentation",
+     *   "parentID": "coll_example"
+     * });
+     */
+    create: Operation<"collections.create", Workspace>;
+    /**
+     * Delete collection trees
+     *
+     * Soft-deletes the selected collections, their descendants, and their entries. The workspace root cannot be deleted. An active schema migration can block this action.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.collections.bulkDelete({
+     *   "ids": [
+     *     "coll_example"
+     *   ]
+     * });
+     */
+    bulkDelete: Operation<"collections.bulkDelete", Workspace>;
+    /**
+     * Delete a collection tree
+     *
+     * Soft-deletes the collection, its descendants, and their entries. The workspace root cannot be deleted. An active schema migration can block this action.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.collections.delete({
+     *   "id": "coll_example"
+     * });
+     */
+    delete: Operation<"collections.delete", Workspace>;
+    /**
+     * Rename a collection
+     *
+     * Updates the collection name. Rejects names already used by a sibling entry or collection. An active schema migration can block this action.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.collections.update({
+     *   "id": "coll_example",
+     *   "name": "Guides"
+     * });
+     */
+    update: Operation<"collections.update", Workspace>;
+    /**
+     * List collections
+     *
+     * Lists collections under the selected ancestor. Pass pagination.nextCursor to the next request while pagination.hasMore is true. The limit is 1 to 100.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.collections.list({
+     *   "collectionID": "coll_example",
+     *   "limit": 20
+     * });
+     */
+    list: Operation<"collections.list", Workspace>;
+  };
+  content: {
+    /**
+     * List published collections
+     *
+     * Returns a flat page of collections from a publication snapshot. The default channel is published. On later pages, pass the returned snapshotID and pagination.nextCursor, and omit channel. Optionally select direct children using collectionID, collectionPath, or collectionSlugPath. Results are ordered by ID, not display order.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.content.listCollections({
+     *   "channel": "published",
+     *   "limit": 20
+     * });
+     */
+    listCollections: Operation<"content.listCollections", Workspace>;
+    /**
+     * List published entries
+     *
+     * Returns a flat page of entries from a publication snapshot. The default channel is published. On later pages, pass the returned snapshotID and pagination.nextCursor, and omit channel. Select direct children using collectionID, collectionPath, or collectionSlugPath, or include nested entries with descendants: true. descendants requires a collection scope. All property filters must match the assigned version. includeContent: true returns validated full content, properties, fragments, assets, and recorded schema metadata. An invalid full item fails the page. Keep the same scope and filters across pages. Results are ordered by ID, not display order.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.content.listEntries({
+     *   "channel": "published",
+     *   "limit": 20
+     * });
+     */
+    listEntries: Operation<"content.listEntries", Workspace>;
+    /**
+     * Get a published entry schema
+     *
+     * Returns the exact recorded effective schema, or null for schema-less content. Uses the same publication access as content.get. Pass its snapshotID for a consistent read; use channel or snapshotID, not both.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.content.getSchema({
+     *   "entryID": "ent_example",
+     *   "channel": "published"
+     * });
+     */
+    getSchema: Operation<"content.getSchema", Workspace>;
+    /**
+     * Download a published asset
+     *
+     * Returns binary image data from a publication snapshot. No API key is required. The asset must belong to the entry in that available snapshot. Use the asset URLs returned with published content.
+     *
+     * @example
+     * await client.content.getAsset({
+     *   "workspaceID": "ws_example",
+     *   "snapshotID": "snp_example",
+     *   "entryID": "ent_example",
+     *   "assetID": "ast_example",
+     *   "variant": "display"
+     * });
+     */
+    getAsset: Operation<"content.getAsset", Workspace>;
+    /**
+     * Get published entry content
+     *
+     * Returns content from a publishing channel or a specific available snapshot. Use channel or snapshotID, never both. The default channel is published. Validates saved content against its recorded schema and returns schema metadata. expectedSchemaHash must match that revision; schema-less content cannot match it. Validation and hash checks run before ETag handling. Supports ETag and If-None-Match; a match returns 304 without a body.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.content.get({
+     *   "entryID": "ent_example",
+     *   "channel": "published"
+     * });
+     */
+    get: Operation<"content.get", Workspace>;
+    /**
+     * Get a published collection tree
+     *
+     * Returns a published collection tree and its snapshot ID. Use channel or snapshotID, never both. The default channel is published. Reuse the snapshot ID for consistent content reads. Supports ETag and If-None-Match; a match returns 304 without a body.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.content.getTree({
+     *   "collectionID": "coll_example",
+     *   "channel": "published"
+     * });
+     */
+    getTree: Operation<"content.getTree", Workspace>;
+  };
+  webhooks: {
+    /**
+     * List webhooks
+     *
+     * Required API key permissions: read:webhooks. Write permissions also grant read access for the same resource.
+     */
+    list: Operation<"webhooks.list", Workspace>;
+    /**
+     * Create a webhook
+     *
+     * Creates an enabled webhook unless `enabled` is false and returns the signing secret once. The caller must be able to read every resource type its events send, and restricted content when included.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    create: Operation<"webhooks.create", Workspace>;
+    /**
+     * Get a webhook
+     *
+     * Required API key permissions: read:webhooks. Write permissions also grant read access for the same resource.
+     */
+    get: Operation<"webhooks.get", Workspace>;
+    /**
+     * Update a webhook
+     *
+     * Checks expectedRevision and validates the merged configuration. A URL change cancels pending deliveries and returns a replacement secret once. Scope changes require authority over the previous and new scope.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    update: Operation<"webhooks.update", Workspace>;
+    /**
+     * Delete a webhook
+     *
+     * Cancels pending deliveries and destroys signing keys. Retains history until its original expiry; a deleted endpoint cannot be replayed.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    delete: Operation<"webhooks.delete", Workspace>;
+    /**
+     * Enable or disable webhooks
+     *
+     * Applies the state to every listed webhook in one transaction, checking each expectedRevision. Enabling checks the scope authority and destination of each webhook. Webhooks already in the state are unchanged.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    bulkSetEnabled: Operation<"webhooks.bulkSetEnabled", Workspace>;
+    /**
+     * Delete webhooks
+     *
+     * Deletes every listed webhook in one transaction, checking each expectedRevision. Each deletion cancels pending deliveries and destroys signing keys; history stays until its original expiry.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    bulkDelete: Operation<"webhooks.bulkDelete", Workspace>;
+    /**
+     * Rotate a webhook secret
+     *
+     * Returns a new secret once. Overlap keeps the old secret valid for 24 hours. Immediate rotation retires it at once. Normal rotation conflicts while a previous overlap remains active.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    rotateSecret: Operation<"webhooks.rotateSecret", Workspace>;
+    /**
+     * Send a webhook test
+     *
+     * Schedules one signed synthetic attempt for this endpoint, including when disabled. The event must be selected by the endpoint. It does not enable the endpoint or change content.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    sendTest: Operation<"webhooks.sendTest", Workspace>;
+    /**
+     * List webhook deliveries
+     *
+     * Returns unexpired history, including for a deleted endpoint. Metadata does not include event payloads.
+     *
+     * Required API key permissions: read:webhooks. Write permissions also grant read access for the same resource.
+     */
+    listDeliveries: Operation<"webhooks.listDeliveries", Workspace>;
+    /**
+     * Get a webhook delivery
+     *
+     * Returns retained delivery metadata and, with content authority, the immutable event payload. Expired deliveries return not found even before physical cleanup.
+     *
+     * Required API key permissions: read:webhooks. Write permissions also grant read access for the same resource.
+     */
+    getDelivery: Operation<"webhooks.getDelivery", Workspace>;
+    /**
+     * List delivery runs
+     *
+     * Required API key permissions: read:webhooks. Write permissions also grant read access for the same resource.
+     */
+    listRuns: Operation<"webhooks.listRuns", Workspace>;
+    /**
+     * List delivery attempts
+     *
+     * Required API key permissions: read:webhooks. Write permissions also grant read access for the same resource.
+     */
+    listAttempts: Operation<"webhooks.listAttempts", Workspace>;
+    /**
+     * Redeliver a webhook event
+     *
+     * Checks the reviewed destination revision and current scope authority. Reuses the original event ID, payload, and expiry. Returns a conflict if a run is active, or the endpoint is disabled or deleted.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    redeliver: Operation<"webhooks.redeliver", Workspace>;
+    /**
+     * Redeliver webhook events
+     *
+     * Replays every listed delivery in one transaction with the same checks as a single redelivery. Any ineligible delivery fails the whole request. Counts as one request for rate limiting.
+     *
+     * Required API key permissions: webhooks. Write permissions also grant read access for the same resource.
+     */
+    bulkRedeliver: Operation<"webhooks.bulkRedeliver", Workspace>;
+  };
+  roles: {
+    /**
+     * List roles
+     *
+     * Returns workspace roles and their permissions.
+     *
+     * Required API key permissions: read:roles. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.roles.list({});
+     */
+    list: Operation<"roles.list", Workspace>;
+    /**
+     * Create a role
+     *
+     * Creates a workspace role. Names are unique without regard to case and must contain 1 to 50 characters after trimming. Requires the Pro plan and permission to delegate the selected permissions.
+     *
+     * Required API key permissions: roles. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.roles.create({
+     *   "name": "Editor",
+     *   "permissions": [
+     *     "content"
+     *   ]
+     * });
+     */
+    create: Operation<"roles.create", Workspace>;
+    /**
+     * Update a role
+     *
+     * Changes a role name or permissions. Names are unique without regard to case. Requires the Pro plan and permission to delegate the selected permissions. Built-in roles have additional restrictions.
+     *
+     * Required API key permissions: roles. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.roles.update({
+     *   "id": "rl_example",
+     *   "name": "Content editor"
+     * });
+     */
+    update: Operation<"roles.update", Workspace>;
+    /**
+     * Delete a role
+     *
+     * Deletes a custom role and updates its assignments. Built-in roles cannot be deleted. Requires the Pro plan.
+     *
+     * Required API key permissions: roles. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.roles.delete({
+     *   "id": "rl_example"
+     * });
+     */
+    delete: Operation<"roles.delete", Workspace>;
+  };
+  search: {
+    /**
+     * Search current content
+     *
+     * Searches current entry content by text and optional property filters. Up to 20 filters and 50 results are allowed. Semantic search is optional, uses 1 AI credit, and has a separate rate limit.
+     *
+     * Required API key permissions: read:entries, read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.search.current({
+     *   "query": "installation",
+     *   "limit": 10
+     * });
+     */
+    current: Operation<"search.current", Workspace>;
+    /**
+     * Search published content
+     *
+     * Searches content published to the required channel. Up to 20 filters and 50 results are allowed. Semantic search is optional, uses 1 AI credit, and has a separate rate limit.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.search.published({
+     *   "query": "installation",
+     *   "channel": "published",
+     *   "limit": 10
+     * });
+     */
+    published: Operation<"search.published", Workspace>;
+    /**
+     * Ask AI about current content
+     *
+     * Returns a complete answer with numbered sources. Requires explicit ai-answers permission in addition to content read permissions. Accepts up to 1,000 question characters, 10 history messages of up to 4,000 characters each, and 20 property filters. Uses 3 AI credits and the Ask AI rate limit. Use a secret key on your server, or a publishable key for published content.
+     *
+     * Required API key permissions: ai-answers, read:entries, read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.search.askCurrent({
+     *   "question": "How do I install Andesine?"
+     * });
+     */
+    askCurrent: Operation<"search.askCurrent", Workspace>;
+    /**
+     * Ask AI about published content
+     *
+     * Returns a complete answer with numbered sources. Requires explicit ai-answers permission in addition to content read permissions. Accepts up to 1,000 question characters, 10 history messages of up to 4,000 characters each, and 20 property filters. Uses 3 AI credits and the Ask AI rate limit. Use a secret key on your server, or a publishable key for published content.
+     *
+     * Required API key permissions: ai-answers, read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.search.askPublished({
+     *   "question": "How do I install Andesine?",
+     *   "channel": "published"
+     * });
+     */
+    askPublished: Operation<"search.askPublished", Workspace>;
+    /**
+     * Stream an AI answer about current content
+     *
+     * Emits sources, textDelta, and completed events over SSE. Uses the same inputs, permissions, AI credits, and rate limit as complete answers. Stream errors use SSE error frames. Never reconnect automatically.
+     *
+     * Required API key permissions: ai-answers, read:entries, read:collections. Write permissions also grant read access for the same resource.
+     */
+    askCurrentStream: Operation<"search.askCurrentStream", Workspace>;
+    /**
+     * Stream an AI answer about published content
+     *
+     * Emits sources, textDelta, and completed events over SSE. Uses the same inputs, permissions, AI credits, and rate limit as complete answers. Stream errors use SSE error frames. Never reconnect automatically.
+     *
+     * Required API key permissions: ai-answers, read:publishing. Write permissions also grant read access for the same resource.
+     */
+    askPublishedStream: Operation<"search.askPublishedStream", Workspace>;
+  };
+  schemas: {
+    /**
+     * Create a local collection schema
+     *
+     * Creates a local schema draft for the collection. Use schemas.get to inspect local and effective schemas.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemas.create({
+     *   "collectionID": "coll_example"
+     * });
+     */
+    create: Operation<"schemas.create", Workspace>;
+    /**
+     * Delete a local schema
+     *
+     * Removes the local schema and recalculates inherited schemas. This can start a content migration. Review possible content removal before setting confirmedDataLoss. Use schemaMigrations.get with a returned migrationID.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemas.delete({
+     *   "schemaID": "sch_example",
+     *   "confirmedDataLoss": false
+     * });
+     */
+    delete: Operation<"schemas.delete", Workspace>;
+    /**
+     * Get an exact schema revision
+     *
+     * Returns the recorded effective definition, including inherited fields. Requires read access to the revision's collection. The definition is independent of the currently active schema.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemas.getRevision({
+     *   "revisionID": "schr_example"
+     * });
+     */
+    getRevision: Operation<"schemas.getRevision", Workspace>;
+    /**
+     * Get collection schemas
+     *
+     * Returns local and effective schema details for the collection, including inheritance.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemas.get({
+     *   "collectionID": "coll_example"
+     * });
+     */
+    get: Operation<"schemas.get", Workspace>;
+    /**
+     * Apply a schema draft
+     *
+     * Creates a schema version from the draft and starts any required migration of affected entry content. Review possible content removal before calling: confirmedDataLoss must be true. Use schemaMigrations.get to follow a returned migrationID.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemas.apply({
+     *   "schemaID": "sch_example",
+     *   "confirmedDataLoss": true,
+     *   "name": "Reviewed schema"
+     * });
+     */
+    apply: Operation<"schemas.apply", Workspace>;
+  };
+  schemaMigrations: {
+    /**
+     * List entries with migration content loss
+     *
+     * Lists accessible, non-deleted entries that lost content in a completed migration. Returns an empty page until completion. Use pagination.nextCursor to continue.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemaMigrations.listContentLossEntries({
+     *   "id": "smg_example",
+     *   "limit": 20
+     * });
+     */
+    listContentLossEntries: Operation<"schemaMigrations.listContentLossEntries", Workspace>;
+    /**
+     * Get the active schema migration
+     *
+     * Returns the active migration for a collection, or null when none is active.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemaMigrations.getActive({
+     *   "collectionID": "coll_example"
+     * });
+     */
+    getActive: Operation<"schemaMigrations.getActive", Workspace>;
+    /**
+     * Get schema migration status
+     *
+     * Returns bounded migration progress and status. Use schemaMigrations.listContentLossEntries for per-entry content loss details. Check status before repeating an operation blocked by this migration.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemaMigrations.get({
+     *   "id": "smg_example"
+     * });
+     */
+    get: Operation<"schemaMigrations.get", Workspace>;
+  };
+  schemaVersions: {
+    /**
+     * List schema versions
+     *
+     * Lists versions of a local collection schema. Pass pagination.nextCursor to the next request while pagination.hasMore is true. The limit is 1 to 100.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemaVersions.list({
+     *   "schemaID": "sch_example",
+     *   "limit": 20
+     * });
+     */
+    list: Operation<"schemaVersions.list", Workspace>;
+    /**
+     * Get a schema version
+     *
+     * Returns a saved schema version and its definition.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemaVersions.get({
+     *   "id": "schv_example"
+     * });
+     */
+    get: Operation<"schemaVersions.get", Workspace>;
+    /**
+     * Rename a schema version
+     *
+     * Changes the saved version name. Set name to null to remove the name.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemaVersions.update({
+     *   "id": "schv_example",
+     *   "name": "Reviewed schema"
+     * });
+     */
+    update: Operation<"schemaVersions.update", Workspace>;
+    /**
+     * Restore a schema version
+     *
+     * Restores the selected definition and starts any required content migration. Review possible content removal before calling: confirmedDataLoss must be true. Use schemaMigrations.get to follow a returned migrationID.
+     *
+     * Required API key permissions: collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.schemaVersions.revert({
+     *   "id": "schv_example",
+     *   "confirmedDataLoss": true
+     * });
+     */
+    revert: Operation<"schemaVersions.revert", Workspace>;
+  };
+  memberships: {
+    /**
+     * List workspace members
+     *
+     * Lists workspace memberships with role and user details. Use pagination.nextCursor to continue with the same filters; concurrent changes can affect later pages.
+     *
+     * Required API key permissions: read:memberships. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.memberships.list({});
+     */
+    list: Operation<"memberships.list", Workspace>;
+    /**
+     * Invite a workspace member
+     *
+     * Creates an invitation and attempts email delivery. Check emailDelivery in the result. Requires the Pro plan and permission to delegate the selected role. Existing membership or pending invitation returns a conflict.
+     *
+     * Required API key permissions: memberships. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.memberships.invite({
+     *   "email": "editor@example.com",
+     *   "roleID": "rl_example"
+     * });
+     */
+    invite: Operation<"memberships.invite", Workspace>;
+    /**
+     * Change a member role
+     *
+     * Assigns a new role to a member. Requires the Pro plan and permission to delegate that role. Administrator assignments have additional restrictions.
+     *
+     * Required API key permissions: memberships. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.memberships.update({
+     *   "id": "ms_example",
+     *   "roleID": "rl_example"
+     * });
+     */
+    update: Operation<"memberships.update", Workspace>;
+    /**
+     * Remove a workspace member
+     *
+     * Removes the membership and its workspace access. Administrator memberships have additional restrictions.
+     *
+     * Required API key permissions: memberships. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.memberships.remove({
+     *   "id": "ms_example"
+     * });
+     */
+    remove: Operation<"memberships.remove", Workspace>;
+    /**
+     * List invitations
+     *
+     * Lists pending, unexpired workspace invitations. Use pagination.nextCursor to continue. Requires the Pro plan.
+     *
+     * Required API key permissions: memberships. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.memberships.listInvites({});
+     */
+    listInvites: Operation<"memberships.listInvites", Workspace>;
+    /**
+     * Resend an invitation
+     *
+     * Attempts email delivery again for a pending invitation. Check emailDelivery in the result. Requires the Pro plan.
+     *
+     * Required API key permissions: memberships. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.memberships.resendInvite({
+     *   "id": "inv_example"
+     * });
+     */
+    resendInvite: Operation<"memberships.resendInvite", Workspace>;
+    /**
+     * Revoke an invitation
+     *
+     * Revokes a pending invitation so it can no longer be accepted. Requires the Pro plan.
+     *
+     * Required API key permissions: memberships. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.memberships.revokeInvite({
+     *   "id": "inv_example"
+     * });
+     */
+    revokeInvite: Operation<"memberships.revokeInvite", Workspace>;
+  };
+  publishing: {
+    /**
+     * Configure collection publishing
+     *
+     * Enables publishing for a collection, or disables it and unpublishes its tree from all channels. When enabling, publish can also publish the latest entry versions.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.setCollection({
+     *   "collectionID": "coll_example",
+     *   "enabled": true,
+     *   "publish": false
+     * });
+     */
+    setCollection: Operation<"publishing.setCollection", Workspace>;
+    /**
+     * Publish a collection tree
+     *
+     * Publishes the latest entry versions in a publishing-enabled collection tree to the channel. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.publishCollection({
+     *   "collectionID": "coll_example",
+     *   "channel": "published"
+     * });
+     */
+    publishCollection: Operation<"publishing.publishCollection", Workspace>;
+    /**
+     * Unpublish a collection tree
+     *
+     * Removes publication assignments for a collection tree from the channel. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.unpublishCollection({
+     *   "collectionID": "coll_example",
+     *   "channel": "published"
+     * });
+     */
+    unpublishCollection: Operation<"publishing.unpublishCollection", Workspace>;
+    /**
+     * Configure publishing for collections
+     *
+     * Enables publishing for the selected collections, or disables it and unpublishes their trees from all channels. When enabling, publish can also publish the latest entry versions.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.bulkSetCollections({
+     *   "ids": [
+     *     "coll_example"
+     *   ],
+     *   "enabled": true,
+     *   "publish": false
+     * });
+     */
+    bulkSetCollections: Operation<"publishing.bulkSetCollections", Workspace>;
+    /**
+     * Publish collection trees
+     *
+     * Publishes the latest entry versions in the selected publishing-enabled collection trees. At least one ID is required. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.bulkPublishCollections({
+     *   "ids": [
+     *     "coll_example"
+     *   ],
+     *   "channel": "published"
+     * });
+     */
+    bulkPublishCollections: Operation<"publishing.bulkPublishCollections", Workspace>;
+    /**
+     * Unpublish collection trees
+     *
+     * Removes publication assignments for the selected collection trees from the channel. At least one ID is required. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.bulkUnpublishCollections({
+     *   "ids": [
+     *     "coll_example"
+     *   ],
+     *   "channel": "published"
+     * });
+     */
+    bulkUnpublishCollections: Operation<"publishing.bulkUnpublishCollections", Workspace>;
+    /**
+     * Publish an entry
+     *
+     * Publishes an existing version, or the latest entry content if versionID is omitted. The entry must be in a publishing-enabled collection. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.publishEntry({
+     *   "entryID": "ent_example",
+     *   "channel": "published"
+     * });
+     */
+    publishEntry: Operation<"publishing.publishEntry", Workspace>;
+    /**
+     * Unpublish an entry
+     *
+     * Removes the entry publication from the channel. Supply versionID to require that version to be assigned; a changed assignment returns a conflict. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.unpublishEntry({
+     *   "entryID": "ent_example",
+     *   "channel": "published",
+     *   "versionID": "ver_example"
+     * });
+     */
+    unpublishEntry: Operation<"publishing.unpublishEntry", Workspace>;
+    /**
+     * Publish entries
+     *
+     * Publishes the selected entries with optional version IDs. Entries must be in publishing-enabled collections. At least one entry is required. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.bulkPublishEntries({
+     *   "entries": [
+     *     {
+     *       "entryID": "ent_example"
+     *     }
+     *   ],
+     *   "channel": "published"
+     * });
+     */
+    bulkPublishEntries: Operation<"publishing.bulkPublishEntries", Workspace>;
+    /**
+     * Unpublish entries
+     *
+     * Removes publication assignments for the selected entries from the channel. At least one ID is required. The default channel is published. Supply expectedSnapshotID from a prior channel read to reject concurrent publication changes.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.bulkUnpublishEntries({
+     *   "ids": [
+     *     "ent_example"
+     *   ],
+     *   "channel": "published"
+     * });
+     */
+    bulkUnpublishEntries: Operation<"publishing.bulkUnpublishEntries", Workspace>;
+    /**
+     * Revert pending publishing changes
+     *
+     * Restores selected drafts to the reviewed publication snapshot. This can remove unpublished items and replace draft content. First review publishing.getChannelContent and pass its snapshotID. Use all: true or specific collectionIDs/entryIDs, never both. Requires write access to affected resources in addition to read:publishing.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.revertChanges({
+     *   "collectionID": "coll_example",
+     *   "snapshotID": "snp_example",
+     *   "entryIDs": [
+     *     "ent_example"
+     *   ],
+     *   "channel": "published"
+     * });
+     */
+    revertChanges: Operation<"publishing.revertChanges", Workspace>;
+    /**
+     * Get a published entry version
+     *
+     * Returns the entry version assigned to a channel, or to an explicit available snapshot, with its recorded schema metadata. Validates content against that revision. expectedSchemaHash must match it; schema-less content cannot match it. The default channel is published.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.getEntryVersion({
+     *   "entryID": "ent_example",
+     *   "channel": "published"
+     * });
+     */
+    getEntryVersion: Operation<"publishing.getEntryVersion", Workspace>;
+    /**
+     * List entry publications
+     *
+     * Returns the entry publication assignments across channels.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.listEntryPublications({
+     *   "entryID": "ent_example"
+     * });
+     */
+    listEntryPublications: Operation<"publishing.listEntryPublications", Workspace>;
+    /**
+     * List publishing channels
+     *
+     * Returns workspace publishing channels. Set includeAssignmentCount to include entry assignment counts.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.listChannels({
+     *   "includeAssignmentCount": true
+     * });
+     */
+    listChannels: Operation<"publishing.listChannels", Workspace>;
+    /**
+     * Create a publishing channel
+     *
+     * Creates a publishing channel from its display name and returns the generated channel code.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.createChannel({
+     *   "name": "Preview"
+     * });
+     */
+    createChannel: Operation<"publishing.createChannel", Workspace>;
+    /**
+     * Get channel content and pending changes
+     *
+     * Returns publication state and pending changes for a publishing root, with the snapshot ID needed to review and revert changes.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.getChannelContent({
+     *   "channel": "published",
+     *   "collectionID": "coll_example"
+     * });
+     */
+    getChannelContent: Operation<"publishing.getChannelContent", Workspace>;
+    /**
+     * Delete a publishing channel
+     *
+     * Deletes a custom channel and its publication assignments. The default published channel cannot be deleted.
+     *
+     * Required API key permissions: publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.publishing.deleteChannel({
+     *   "code": "preview"
+     * });
+     */
+    deleteChannel: Operation<"publishing.deleteChannel", Workspace>;
+  };
+  workspaces: {
+    /**
+     * List available workspaces
+     *
+     * Lists workspaces available to the OAuth user, with current role permissions and plan access. Browser sessions can list workspaces across signed-in accounts. Does not require workspace selection and does not count toward API usage.
+     */
+    list: Operation<"workspaces.list", Workspace>;
+  };
+  versions: {
+    /**
+     * Create an entry version
+     *
+     * Saves a version of the current entry content. Optionally assigns a name.
+     *
+     * Required API key permissions: versions. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.versions.create({
+     *   "entryID": "ent_example",
+     *   "name": "Before release"
+     * });
+     */
+    create: Operation<"versions.create", Workspace>;
+    /**
+     * List entry versions
+     *
+     * Lists saved entry versions. Pass pagination.nextCursor to the next request while pagination.hasMore is true. The limit is 1 to 100.
+     *
+     * Required API key permissions: read:versions. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.versions.list({
+     *   "entryID": "ent_example",
+     *   "limit": 20
+     * });
+     */
+    list: Operation<"versions.list", Workspace>;
+    /**
+     * Get an entry version
+     *
+     * Returns the saved content and recorded schema metadata of an entry version. Validates against its recorded revision, including historical versions. expectedSchemaHash must match that revision; schema-less content cannot match it.
+     *
+     * Required API key permissions: read:versions. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.versions.get({
+     *   "id": "ver_example"
+     * });
+     */
+    get: Operation<"versions.get", Workspace>;
+    /**
+     * Rename an entry version
+     *
+     * Changes the saved version name. Set name to null to remove the name.
+     *
+     * Required API key permissions: versions. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.versions.update({
+     *   "id": "ver_example",
+     *   "name": "Release candidate"
+     * });
+     */
+    update: Operation<"versions.update", Workspace>;
+    /**
+     * Restore an entry version
+     *
+     * Restores saved content to the current entry and returns the resulting version. An active schema migration can block this action.
+     *
+     * Required API key permissions: versions. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.versions.revert({
+     *   "id": "ver_example"
+     * });
+     */
+    revert: Operation<"versions.revert", Workspace>;
+  };
+  typeMetadata: {
+    /**
+     * Get current content type metadata
+     *
+     * Read-only bulk metadata for type generation. Returns one consistent database snapshot of accessible collections and their active effective schemas, including inheritance. Optional entry/tree data requires read:entries in addition to read:collections. Explicit unavailable collection selectors fail. Active schema migrations in the selected collections return a conflict. No entry content is loaded. Schema-free collections use general types without warnings.
+     *
+     * Required API key permissions: read:collections. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.typeMetadata.getCurrent({
+     *   "collections": [
+     *     "/Tutorials"
+     *   ],
+     *   "includeEntries": false
+     * });
+     */
+    getCurrent: Operation<"typeMetadata.getCurrent", Workspace>;
+    /**
+     * Get published content type metadata
+     *
+     * Read-only bulk metadata for type generation. Resolves a channel once (published by default), or reads a retained snapshot. Uses publication paths, names, and exact entry-version schema revisions; never substitutes current schemas. Supports mixed revisions and schema-free entries. Empty collections use general types without warnings. Includes selected subtrees; no selectors means all published collections and root entries. Publication-access rules match content.get. No entry content is loaded. Reuse source.snapshotID for related reads. The fingerprint changes only when returned type metadata changes, not when content-only publication creates a new snapshot.
+     *
+     * Required API key permissions: read:publishing. Write permissions also grant read access for the same resource.
+     *
+     * @example
+     * await client.typeMetadata.getPublished({
+     *   "channel": "published",
+     *   "collections": [
+     *     "/Tutorials"
+     *   ]
+     * });
+     */
+    getPublished: Operation<"typeMetadata.getPublished", Workspace>;
+  };
+}
+//#endregion
+//#region src/content-client.d.ts
+interface ContentClient<Workspace extends WorkspaceTypeMap = WorkspaceTypeMap> extends ContentResources<Workspace> {
+  /**
+   * Iterate published entries, automatically keeping the first page's snapshot.
+   *
+   * @param input - List scope, filters, and page size. Set includeContent to true for full entries.
+   * To resume, supply both cursor and snapshotID, or use a client from atSnapshot().
+   * @param options - Options for each request. The timeout applies to each page separately.
+   * @returns A lazy iterator in API order. Breaking the loop prevents further requests.
+   * @throws API errors without switching to a newer snapshot, including expired snapshots.
+   * @example
+   * for await (const entry of client.content.paginateEntries({
+   *   collectionPath: "/Tutorials", includeContent: true
+   * })) console.log(entry.properties);
+   */
+  paginateEntries<const Input extends EntryListInput = Record<string, never>>(input?: Input, options?: ContentPaginationOptions): AsyncGenerator<ContentListOutput<Input, Workspace>["data"][number]>;
+  /**
+   * Iterate entry pages while retaining snapshot metadata and resume cursors.
+   *
+   * The first response selects the snapshot; later requests omit channel and reuse that snapshot.
+   * Scope and filters are reused for every page. An existing atSnapshot() binding is respected.
+   * @param input - List options. Resuming requires cursor and its snapshot, with the same filters.
+   * @param options - Per-page request options, including cancellation and timeout.
+   * @returns Lazy pages with includeContent-dependent item types and snapshot metadata.
+   * @throws API errors or an error for a missing/repeated cursor or changed response snapshot.
+   */
+  paginateEntryPages<const Input extends EntryListInput = Record<string, never>>(input?: Input, options?: ContentPaginationOptions): AsyncGenerator<ContentListOutput<Input, Workspace>>;
+  /**
+   * Iterate published collections using the first page's snapshot for all later pages.
+   *
+   * @param input - Collection scope and page size. To resume, supply cursor and its snapshot.
+   * @param options - Per-page request options. Break the loop to stop requesting pages.
+   * @returns A lazy iterator of collection summaries in API order.
+   * @throws API and pagination errors; unavailable snapshots are never replaced automatically.
+   */
+  paginateCollections(input?: OperationInput<"content.listCollections">, options?: ContentPaginationOptions): AsyncGenerator<OperationOutput<"content.listCollections">["data"][number]>;
+  /**
+   * Iterate collection pages with snapshot metadata and resume cursors.
+   *
+   * @param input - List options. Use the same scope and snapshot when resuming a cursor.
+   * @param options - Options applied to each request, including cancellation and timeout.
+   * @returns Lazy pages pinned to the first response's snapshot or the atSnapshot() binding.
+   * @throws API errors or an error for a missing/repeated cursor or changed response snapshot.
+   */
+  paginateCollectionPages(input?: OperationInput<"content.listCollections">, options?: ContentPaginationOptions): AsyncGenerator<OperationOutput<"content.listCollections">>;
+}
+type ContentResources<Workspace extends WorkspaceTypeMap = WorkspaceTypeMap> = APIResources<Workspace>["content"];
+type EntryListInput = OperationInput<"content.listEntries">;
+type ContentPaginationOptions = RequestOptions & {
+  response?: "data";
+};
+//#endregion
+//#region src/client.d.ts
+interface AndesineClient<Workspace extends WorkspaceTypeMap = WorkspaceTypeMap> extends APIResources<Workspace> {
+  content: ContentClient<Workspace>;
+  /**
+   * Bind published-content reads and pagination to an existing snapshot.
+   * @param snapshotID - Snapshot ID returned by a published-content response.
+   * @returns Content methods, including snapshot-aware entry and collection iterators.
+   * No request is made until a method is called or an iterator is consumed.
+   * @throws TypeError if a later request supplies a channel or a different snapshot ID.
+   */
+  atSnapshot(snapshotID: string): ContentClient<Workspace>;
+}
+interface ClientOptions {
+  /** HTTP(S) API root, including any deployment prefix. Defaults to https://api.andesine.app. */
+  baseURL?: string;
+  /**
+   * Bearer API key. Defaults to process.env.ANDESINE_API_KEY when available, read at creation.
+   * Pass an empty string to disable this fallback. Keep private keys on your server;
+   * the key is omitted on anonymous operations.
+   */
+  apiKey?: string;
+  /** OAuth access token. Disables the API-key environment fallback. Cannot be combined with apiKey.
+   * Supply x-workspace-id through headers for workspace operations. The SDK does not refresh tokens.
+   */
+  accessToken?: string;
+  /** Fetch implementation to use instead of globalThis.fetch. */
+  fetch?: typeof fetch;
+  /** Default headers. Request headers override these; the configured credential supplies Authorization. */
+  headers?: HeadersInit;
+  /** Timeout in milliseconds, including stream consumption. Defaults to 30,000; 0 disables it. */
+  timeout?: number;
+  /** Extra attempts for eligible GET failures. Defaults to 0. Other methods are never retried. */
+  retries?: number;
+}
+/**
+ * Create a typed API client for a hosted or self-hosted Andesine instance.
+ *
+ * Methods return response data by default. Use response: "full" for status and headers,
+ * including conditional reads that can return 304. Creation does not make a request.
+ * An optional Workspace type map narrows known content selectors at compile time only.
+ * It does not choose credentials, a workspace, a channel, or a snapshot, or check response schemas.
+ * @param config - Optional API root, credentials, transport, and request defaults.
+ * Defaults to https://api.andesine.app and process.env.ANDESINE_API_KEY when available.
+ * Runtimes without process.env use no default key. No environment files are loaded.
+ * @returns API resources and helpers for published-content snapshots and pagination.
+ * @throws TypeError if both credential options are set, or if baseURL is not HTTP(S) or includes credentials, a query, or a fragment.
+ * Request failures throw AndesineAPIError; abort and timeout reasons are preserved.
+ * @example
+ * const client = createClient();
+ * const page = await client.content.get({ path: "/Docs/Welcome" });
+ */
+declare const createClient: <Workspace extends WorkspaceTypeMap = WorkspaceTypeMap>(config?: ClientOptions) => AndesineClient<Workspace>;
+//#endregion
+//#region src/content-url.d.ts
+/** A decoded canonical path, optionally with a decoded heading anchor. */
+interface ContentLocation {
+  path: string;
+  /** Authoritative derived path returned by the API, including ID fallbacks. */
+  slugPath?: string;
+  anchor?: string;
+}
+interface ContentURLOptions {
+  /** Use derived slugs (default), or percent-encoded original names. */
+  format?: "slug" | "name";
+  /** Decoded collection prefix to remove, matched on whole segments. Defaults to "/". */
+  rootPath?: string;
+  /**
+   * Destination root: a root-relative URL such as "/docs", or an absolute HTTP(S) URL.
+   * Its pathname is retained as a prefix. Queries, fragments, and credentials are not allowed.
+   * Defaults to "/". Supply this as a URL; its pathname may already be percent-encoded.
+   */
+  baseURL?: string;
+}
+/**
+ * Convert a canonical Andesine path or search/citation location to a website URL.
+ *
+ * Uses the API slugPath when supplied, or derives slugs from decoded names.
+ * Set format to "name" to preserve names. Heading anchors are encoded without slug conversion.
+ * This is a pure function: it does not resolve IDs, fetch content, or pin a snapshot.
+ * @param source - An absolute decoded path, or an API location with path, slugPath, and optional anchor.
+ * Collection-ID-relative selectors must first be resolved through the API to a canonical path.
+ * @param options - Source collection root and destination URL prefix.
+ * @returns A root-relative URL by default, or an absolute URL when baseURL is absolute.
+ * The source root itself maps to the destination root without adding a trailing slash.
+ * @throws TypeError for invalid paths, a source outside rootPath, an invalid baseURL,
+ * or a symbol-only name without an API slugPath. Pass the API object for ID fallbacks.
+ * @example
+ * toContentURL({ path: "/Docs/Getting started", anchor: "install" }, {
+ *   rootPath: "/Docs", baseURL: "/docs"
+ * }); // "/docs/getting-started#install"
+ */
+declare const toContentURL: (source: string | ContentLocation, options?: ContentURLOptions) => string;
+//#endregion
+//#region src/error.d.ts
+/** An HTTP API failure with its response, error code, contract data, and suggested next steps. */
+declare class AndesineAPIError extends Error {
+  readonly defined: boolean;
+  readonly status: number;
+  readonly code: string;
+  readonly data: unknown;
+  readonly response: Response;
+  /**
+   * @param response - Failed Fetch response, retained for status and headers such as Retry-After.
+   * @param body - Parsed error envelope, or the original body for an unrecognized error format.
+   */
+  constructor(response: Response, body: unknown);
+  /**
+   * Check and narrow the code and data of an error declared by the API contract.
+   * @param code - Contract error code to match.
+   * @returns True only when the API marks the error as defined and its code matches.
+   */
+  is<C extends APIErrorCode>(code: C): this is this & {
+    defined: true;
+    code: C;
+    data: APIErrorData<C>;
+  };
+  /** Suggested next steps. Do not use the wording for program logic. */
+  get hints(): string[];
+}
+/** An API error frame received after SSE headers. status is the frame status, not HTTP 200. */
+declare class AndesineStreamError extends AndesineAPIError {
+  readonly status: number;
+  /**
+   * @param response - Original SSE response; response.status retains its actual HTTP status.
+   * @param body - Parsed error frame. Its numeric status overrides the HTTP status on this error.
+   */
+  constructor(response: Response, body: unknown);
+}
+/** A local invalid/incomplete stream failure. It does not invent an API error or HTTP status. */
+declare class AndesineStreamProtocolError extends Error {
+  readonly code: "INVALID_STREAM" | "INCOMPLETE_STREAM";
+  readonly response: Response;
+  /**
+   * @param code - INVALID_STREAM for malformed events; INCOMPLETE_STREAM for missing completion.
+   * @param response - Original SSE response for inspection.
+   * @param message - Description of the protocol failure.
+   * @param options - Optional underlying cause.
+   */
+  constructor(code: "INVALID_STREAM" | "INCOMPLETE_STREAM", response: Response, message: string, options?: ErrorOptions);
+}
+declare namespace types_d_exports {
+  export { Answer, AnswerEvent, AnswerHistoryMessage, AnswerSource, Asset, AssetAnalysis, AssetAnalysisStatus, AssetConflictErrorData, AssetFile, AssetFileFormat, AssetSearchResult, AssetStatus, AssetStorageErrorData, AssetUploadRegistration, AssetValidationErrorData, AssetVariant, AssetsAttachError, AssetsAttachInput, AssetsAttachOutput, AssetsGetError, AssetsGetInput, AssetsGetOutput, AssetsImportURLError, AssetsImportURLInput, AssetsImportURLOutput, AssetsRegisterError, AssetsRegisterInput, AssetsRegisterOutput, AssetsSearchError, AssetsSearchInput, AssetsSearchOutput, AssetsUploadError, AssetsUploadInput, AssetsUploadOutput, AuthGetIdentityError, AuthGetIdentityInput, AuthGetIdentityOutput, BaseRole, BooleanPropertyFilter, ChannelContent, ChannelContentCollection, ChannelContentEntry, ChannelContentStatus, Collection, CollectionSchema, CollectionsBulkDeleteError, CollectionsBulkDeleteInput, CollectionsBulkDeleteOutput, CollectionsCreateError, CollectionsCreateInput, CollectionsCreateOutput, CollectionsDeleteError, CollectionsDeleteInput, CollectionsDeleteOutput, CollectionsListError, CollectionsListInput, CollectionsListOutput, CollectionsUpdateError, CollectionsUpdateInput, CollectionsUpdateOutput, ComparisonOperator, ContentGetAssetError, ContentGetAssetInput, ContentGetAssetOutput, ContentGetError, ContentGetInput, ContentGetOutput, ContentGetSchemaError, ContentGetSchemaInput, ContentGetSchemaOutput, ContentGetTreeError, ContentGetTreeInput, ContentGetTreeOutput, ContentListCollectionsError, ContentListCollectionsInput, ContentListCollectionsOutput, ContentListEntriesError, ContentListEntriesInput, ContentListEntriesOutput, ContentMark, ContentMarkInput, ContentNameConflictErrorData, ContentNode, ContentNodeInput, ContentSchemaInvalidErrorData, ContentSchemaIssue, ContentSchemaMetadata, ContentSchemaMismatchErrorData, DatePropertyFilter, EffectiveCollectionSchema, EntriesBulkDeleteError, EntriesBulkDeleteInput, EntriesBulkDeleteOutput, EntriesCreateError, EntriesCreateInput, EntriesCreateOutput, EntriesDeleteError, EntriesDeleteInput, EntriesDeleteOutput, EntriesGetError, EntriesGetInput, EntriesGetOutput, EntriesListError, EntriesListInput, EntriesListOutput, EntriesUpdateError, EntriesUpdateInput, EntriesUpdateOutput, Entry, EntryFragment, EntryProperty, EntryPropertyKind, EntryPropertyValue, EntryPublication, EntryPublicationChannel, EntrySummary, EntryVersion, EntryVersionSummary, ErrorData, ForbiddenErrorData, Identity, InstanceGetError, InstanceGetInput, InstanceGetOutput, InstanceInfo, Invite, InviteDeliveryResult, InvitePendingErrorData, InviteStatus, LocalCollectionSchema, Membership, MembershipExistsErrorData, MembershipInviteResult, MembershipsInviteError, MembershipsInviteInput, MembershipsInviteOutput, MembershipsListError, MembershipsListInput, MembershipsListInvitesError, MembershipsListInvitesInput, MembershipsListInvitesOutput, MembershipsListOutput, MembershipsRemoveError, MembershipsRemoveInput, MembershipsRemoveOutput, MembershipsResendInviteError, MembershipsResendInviteInput, MembershipsResendInviteOutput, MembershipsRevokeInviteError, MembershipsRevokeInviteInput, MembershipsRevokeInviteOutput, MembershipsUpdateError, MembershipsUpdateInput, MembershipsUpdateOutput, NumberPropertyFilter, Pagination, Permission, PropertyFilter, PublishEntryTarget, PublishedAnswer, PublishedAnswerEvent, PublishedAnswerSource, PublishedAsset, PublishedCollection, PublishedCollectionSummary, PublishedContent, PublishedEntriesResult, PublishedEntry, PublishedEntryContent, PublishedEntrySummary, PublishedSearchResult, PublishedTree, PublishedVersion, PublishingBulkPublishCollectionsError, PublishingBulkPublishCollectionsInput, PublishingBulkPublishCollectionsOutput, PublishingBulkPublishEntriesError, PublishingBulkPublishEntriesInput, PublishingBulkPublishEntriesOutput, PublishingBulkSetCollectionsError, PublishingBulkSetCollectionsInput, PublishingBulkSetCollectionsOutput, PublishingBulkUnpublishCollectionsError, PublishingBulkUnpublishCollectionsInput, PublishingBulkUnpublishCollectionsOutput, PublishingBulkUnpublishEntriesError, PublishingBulkUnpublishEntriesInput, PublishingBulkUnpublishEntriesOutput, PublishingChannel, PublishingChannelCode, PublishingChannelListItem, PublishingCreateChannelError, PublishingCreateChannelInput, PublishingCreateChannelOutput, PublishingDeleteChannelError, PublishingDeleteChannelInput, PublishingDeleteChannelOutput, PublishingGetChannelContentError, PublishingGetChannelContentInput, PublishingGetChannelContentOutput, PublishingGetEntryVersionError, PublishingGetEntryVersionInput, PublishingGetEntryVersionOutput, PublishingListChannelsError, PublishingListChannelsInput, PublishingListChannelsOutput, PublishingListEntryPublicationsError, PublishingListEntryPublicationsInput, PublishingListEntryPublicationsOutput, PublishingPublishCollectionError, PublishingPublishCollectionInput, PublishingPublishCollectionOutput, PublishingPublishEntryError, PublishingPublishEntryInput, PublishingPublishEntryOutput, PublishingRevertChangesError, PublishingRevertChangesInput, PublishingRevertChangesOutput, PublishingSetCollectionError, PublishingSetCollectionInput, PublishingSetCollectionOutput, PublishingSnapshotErrorData, PublishingUnpublishCollectionError, PublishingUnpublishCollectionInput, PublishingUnpublishCollectionOutput, PublishingUnpublishEntryError, PublishingUnpublishEntryInput, PublishingUnpublishEntryOutput, RateLimitErrorData, ResolvedSchemaDefinition, ResolvedSchemaField, RevertPublishingChangesResult, Role, RolesCreateError, RolesCreateInput, RolesCreateOutput, RolesDeleteError, RolesDeleteInput, RolesDeleteOutput, RolesListError, RolesListInput, RolesListOutput, RolesUpdateError, RolesUpdateInput, RolesUpdateOutput, SchemaApplicationResult, SchemaBlockType, SchemaDefinition, SchemaDraftDefinition, SchemaField, SchemaFieldKeyConflictErrorData, SchemaFieldSource, SchemaFragment, SchemaMigration, SchemaMigrationContentLossEntry, SchemaMigrationErrorData, SchemaMigrationStatus, SchemaMigrationsGetActiveError, SchemaMigrationsGetActiveInput, SchemaMigrationsGetActiveOutput, SchemaMigrationsGetError, SchemaMigrationsGetInput, SchemaMigrationsGetOutput, SchemaMigrationsListContentLossEntriesError, SchemaMigrationsListContentLossEntriesInput, SchemaMigrationsListContentLossEntriesOutput, SchemaProperty, SchemaPropertyValue, SchemaRevision, SchemaVersion, SchemaVersionSummary, SchemaVersionsGetError, SchemaVersionsGetInput, SchemaVersionsGetOutput, SchemaVersionsListError, SchemaVersionsListInput, SchemaVersionsListOutput, SchemaVersionsRevertError, SchemaVersionsRevertInput, SchemaVersionsRevertOutput, SchemaVersionsUpdateError, SchemaVersionsUpdateInput, SchemaVersionsUpdateOutput, SchemasApplyError, SchemasApplyInput, SchemasApplyOutput, SchemasCreateError, SchemasCreateInput, SchemasCreateOutput, SchemasDeleteError, SchemasDeleteInput, SchemasDeleteOutput, SchemasGetError, SchemasGetInput, SchemasGetOutput, SchemasGetRevisionError, SchemasGetRevisionInput, SchemasGetRevisionOutput, SearchAskCurrentError, SearchAskCurrentInput, SearchAskCurrentOutput, SearchAskCurrentStreamError, SearchAskCurrentStreamInput, SearchAskCurrentStreamOutput, SearchAskPublishedError, SearchAskPublishedInput, SearchAskPublishedOutput, SearchAskPublishedStreamError, SearchAskPublishedStreamInput, SearchAskPublishedStreamOutput, SearchCurrentError, SearchCurrentInput, SearchCurrentOutput, SearchPropertyValue, SearchPublishedError, SearchPublishedInput, SearchPublishedOutput, SearchResult, SearchResults, TextPropertyFilter, TypeMetadata, TypeMetadataCollection, TypeMetadataEntry, TypeMetadataGetCurrentError, TypeMetadataGetCurrentInput, TypeMetadataGetCurrentOutput, TypeMetadataGetPublishedError, TypeMetadataGetPublishedInput, TypeMetadataGetPublishedOutput, TypeMetadataTree, UnpublishedEntriesResult, UserProfile, ValidationErrorData, ValidationIssue, VersionReason, VersionsCreateError, VersionsCreateInput, VersionsCreateOutput, VersionsGetError, VersionsGetInput, VersionsGetOutput, VersionsListError, VersionsListInput, VersionsListOutput, VersionsRevertError, VersionsRevertInput, VersionsRevertOutput, VersionsUpdateError, VersionsUpdateInput, VersionsUpdateOutput, WebhookAttempt, WebhookDelivery, WebhookEndpoint, WebhookEvent, WebhookEventName, WebhookRun, WebhooksBulkDeleteError, WebhooksBulkDeleteInput, WebhooksBulkDeleteOutput, WebhooksBulkRedeliverError, WebhooksBulkRedeliverInput, WebhooksBulkRedeliverOutput, WebhooksBulkSetEnabledError, WebhooksBulkSetEnabledInput, WebhooksBulkSetEnabledOutput, WebhooksCreateError, WebhooksCreateInput, WebhooksCreateOutput, WebhooksDeleteError, WebhooksDeleteInput, WebhooksDeleteOutput, WebhooksGetDeliveryError, WebhooksGetDeliveryInput, WebhooksGetDeliveryOutput, WebhooksGetError, WebhooksGetInput, WebhooksGetOutput, WebhooksListAttemptsError, WebhooksListAttemptsInput, WebhooksListAttemptsOutput, WebhooksListDeliveriesError, WebhooksListDeliveriesInput, WebhooksListDeliveriesOutput, WebhooksListError, WebhooksListInput, WebhooksListOutput, WebhooksListRunsError, WebhooksListRunsInput, WebhooksListRunsOutput, WebhooksRedeliverError, WebhooksRedeliverInput, WebhooksRedeliverOutput, WebhooksRotateSecretError, WebhooksRotateSecretInput, WebhooksRotateSecretOutput, WebhooksSendTestError, WebhooksSendTestInput, WebhooksSendTestOutput, WebhooksUpdateError, WebhooksUpdateInput, WebhooksUpdateOutput, WorkspaceListItem, WorkspacesListError, WorkspacesListInput, WorkspacesListOutput };
+}
+type AssetsAttachError = OperationError<"assets.attach">;
+type AssetsAttachInput = OperationInput<"assets.attach">;
+type AssetsAttachOutput = OperationOutput<"assets.attach">;
+type AssetsGetError = OperationError<"assets.get">;
+type AssetsGetInput = OperationInput<"assets.get">;
+type AssetsGetOutput = OperationOutput<"assets.get">;
+type AssetsImportURLError = OperationError<"assets.importURL">;
+type AssetsImportURLInput = OperationInput<"assets.importURL">;
+type AssetsImportURLOutput = OperationOutput<"assets.importURL">;
+type AssetsRegisterError = OperationError<"assets.register">;
+type AssetsRegisterInput = OperationInput<"assets.register">;
+type AssetsRegisterOutput = OperationOutput<"assets.register">;
+type AssetsSearchError = OperationError<"assets.search">;
+type AssetsSearchInput = OperationInput<"assets.search">;
+type AssetsSearchOutput = OperationOutput<"assets.search">;
+type AssetsUploadError = OperationError<"assets.upload">;
+type AssetsUploadInput = OperationInput<"assets.upload">;
+type AssetsUploadOutput = OperationOutput<"assets.upload">;
+type AuthGetIdentityError = OperationError<"auth.getIdentity">;
+type AuthGetIdentityInput = OperationInput<"auth.getIdentity">;
+type AuthGetIdentityOutput = OperationOutput<"auth.getIdentity">;
+type CollectionsBulkDeleteError = OperationError<"collections.bulkDelete">;
+type CollectionsBulkDeleteInput = OperationInput<"collections.bulkDelete">;
+type CollectionsBulkDeleteOutput = OperationOutput<"collections.bulkDelete">;
+type CollectionsCreateError = OperationError<"collections.create">;
+type CollectionsCreateInput = OperationInput<"collections.create">;
+type CollectionsCreateOutput = OperationOutput<"collections.create">;
+type CollectionsDeleteError = OperationError<"collections.delete">;
+type CollectionsDeleteInput = OperationInput<"collections.delete">;
+type CollectionsDeleteOutput = OperationOutput<"collections.delete">;
+type CollectionsListError = OperationError<"collections.list">;
+type CollectionsListInput = OperationInput<"collections.list">;
+type CollectionsListOutput = OperationOutput<"collections.list">;
+type CollectionsUpdateError = OperationError<"collections.update">;
+type CollectionsUpdateInput = OperationInput<"collections.update">;
+type CollectionsUpdateOutput = OperationOutput<"collections.update">;
+type ContentGetAssetError = OperationError<"content.getAsset">;
+type ContentGetAssetInput = OperationInput<"content.getAsset">;
+type ContentGetAssetOutput = OperationOutput<"content.getAsset">;
+type ContentGetError = OperationError<"content.get">;
+type ContentGetInput = OperationInput<"content.get">;
+type ContentGetOutput = OperationOutput<"content.get">;
+type ContentGetSchemaError = OperationError<"content.getSchema">;
+type ContentGetSchemaInput = OperationInput<"content.getSchema">;
+type ContentGetSchemaOutput = OperationOutput<"content.getSchema">;
+type ContentGetTreeError = OperationError<"content.getTree">;
+type ContentGetTreeInput = OperationInput<"content.getTree">;
+type ContentGetTreeOutput = OperationOutput<"content.getTree">;
+type ContentListCollectionsError = OperationError<"content.listCollections">;
+type ContentListCollectionsInput = OperationInput<"content.listCollections">;
+type ContentListCollectionsOutput = OperationOutput<"content.listCollections">;
+type ContentListEntriesError = OperationError<"content.listEntries">;
+type ContentListEntriesInput = OperationInput<"content.listEntries">;
+type ContentListEntriesOutput = OperationOutput<"content.listEntries">;
+type EntriesBulkDeleteError = OperationError<"entries.bulkDelete">;
+type EntriesBulkDeleteInput = OperationInput<"entries.bulkDelete">;
+type EntriesBulkDeleteOutput = OperationOutput<"entries.bulkDelete">;
+type EntriesCreateError = OperationError<"entries.create">;
+type EntriesCreateInput = OperationInput<"entries.create">;
+type EntriesCreateOutput = OperationOutput<"entries.create">;
+type EntriesDeleteError = OperationError<"entries.delete">;
+type EntriesDeleteInput = OperationInput<"entries.delete">;
+type EntriesDeleteOutput = OperationOutput<"entries.delete">;
+type EntriesGetError = OperationError<"entries.get">;
+type EntriesGetInput = OperationInput<"entries.get">;
+type EntriesGetOutput = OperationOutput<"entries.get">;
+type EntriesListError = OperationError<"entries.list">;
+type EntriesListInput = OperationInput<"entries.list">;
+type EntriesListOutput = OperationOutput<"entries.list">;
+type EntriesUpdateError = OperationError<"entries.update">;
+type EntriesUpdateInput = OperationInput<"entries.update">;
+type EntriesUpdateOutput = OperationOutput<"entries.update">;
+type InstanceGetError = OperationError<"instance.get">;
+type InstanceGetInput = OperationInput<"instance.get">;
+type InstanceGetOutput = OperationOutput<"instance.get">;
+type MembershipsInviteError = OperationError<"memberships.invite">;
+type MembershipsInviteInput = OperationInput<"memberships.invite">;
+type MembershipsInviteOutput = OperationOutput<"memberships.invite">;
+type MembershipsListError = OperationError<"memberships.list">;
+type MembershipsListInput = OperationInput<"memberships.list">;
+type MembershipsListInvitesError = OperationError<"memberships.listInvites">;
+type MembershipsListInvitesInput = OperationInput<"memberships.listInvites">;
+type MembershipsListInvitesOutput = OperationOutput<"memberships.listInvites">;
+type MembershipsListOutput = OperationOutput<"memberships.list">;
+type MembershipsRemoveError = OperationError<"memberships.remove">;
+type MembershipsRemoveInput = OperationInput<"memberships.remove">;
+type MembershipsRemoveOutput = OperationOutput<"memberships.remove">;
+type MembershipsResendInviteError = OperationError<"memberships.resendInvite">;
+type MembershipsResendInviteInput = OperationInput<"memberships.resendInvite">;
+type MembershipsResendInviteOutput = OperationOutput<"memberships.resendInvite">;
+type MembershipsRevokeInviteError = OperationError<"memberships.revokeInvite">;
+type MembershipsRevokeInviteInput = OperationInput<"memberships.revokeInvite">;
+type MembershipsRevokeInviteOutput = OperationOutput<"memberships.revokeInvite">;
+type MembershipsUpdateError = OperationError<"memberships.update">;
+type MembershipsUpdateInput = OperationInput<"memberships.update">;
+type MembershipsUpdateOutput = OperationOutput<"memberships.update">;
+type PublishingBulkPublishCollectionsError = OperationError<"publishing.bulkPublishCollections">;
+type PublishingBulkPublishCollectionsInput = OperationInput<"publishing.bulkPublishCollections">;
+type PublishingBulkPublishCollectionsOutput = OperationOutput<"publishing.bulkPublishCollections">;
+type PublishingBulkPublishEntriesError = OperationError<"publishing.bulkPublishEntries">;
+type PublishingBulkPublishEntriesInput = OperationInput<"publishing.bulkPublishEntries">;
+type PublishingBulkPublishEntriesOutput = OperationOutput<"publishing.bulkPublishEntries">;
+type PublishingBulkSetCollectionsError = OperationError<"publishing.bulkSetCollections">;
+type PublishingBulkSetCollectionsInput = OperationInput<"publishing.bulkSetCollections">;
+type PublishingBulkSetCollectionsOutput = OperationOutput<"publishing.bulkSetCollections">;
+type PublishingBulkUnpublishCollectionsError = OperationError<"publishing.bulkUnpublishCollections">;
+type PublishingBulkUnpublishCollectionsInput = OperationInput<"publishing.bulkUnpublishCollections">;
+type PublishingBulkUnpublishCollectionsOutput = OperationOutput<"publishing.bulkUnpublishCollections">;
+type PublishingBulkUnpublishEntriesError = OperationError<"publishing.bulkUnpublishEntries">;
+type PublishingBulkUnpublishEntriesInput = OperationInput<"publishing.bulkUnpublishEntries">;
+type PublishingBulkUnpublishEntriesOutput = OperationOutput<"publishing.bulkUnpublishEntries">;
+type PublishingCreateChannelError = OperationError<"publishing.createChannel">;
+type PublishingCreateChannelInput = OperationInput<"publishing.createChannel">;
+type PublishingCreateChannelOutput = OperationOutput<"publishing.createChannel">;
+type PublishingDeleteChannelError = OperationError<"publishing.deleteChannel">;
+type PublishingDeleteChannelInput = OperationInput<"publishing.deleteChannel">;
+type PublishingDeleteChannelOutput = OperationOutput<"publishing.deleteChannel">;
+type PublishingGetChannelContentError = OperationError<"publishing.getChannelContent">;
+type PublishingGetChannelContentInput = OperationInput<"publishing.getChannelContent">;
+type PublishingGetChannelContentOutput = OperationOutput<"publishing.getChannelContent">;
+type PublishingGetEntryVersionError = OperationError<"publishing.getEntryVersion">;
+type PublishingGetEntryVersionInput = OperationInput<"publishing.getEntryVersion">;
+type PublishingGetEntryVersionOutput = OperationOutput<"publishing.getEntryVersion">;
+type PublishingListChannelsError = OperationError<"publishing.listChannels">;
+type PublishingListChannelsInput = OperationInput<"publishing.listChannels">;
+type PublishingListChannelsOutput = OperationOutput<"publishing.listChannels">;
+type PublishingListEntryPublicationsError = OperationError<"publishing.listEntryPublications">;
+type PublishingListEntryPublicationsInput = OperationInput<"publishing.listEntryPublications">;
+type PublishingListEntryPublicationsOutput = OperationOutput<"publishing.listEntryPublications">;
+type PublishingPublishCollectionError = OperationError<"publishing.publishCollection">;
+type PublishingPublishCollectionInput = OperationInput<"publishing.publishCollection">;
+type PublishingPublishCollectionOutput = OperationOutput<"publishing.publishCollection">;
+type PublishingPublishEntryError = OperationError<"publishing.publishEntry">;
+type PublishingPublishEntryInput = OperationInput<"publishing.publishEntry">;
+type PublishingPublishEntryOutput = OperationOutput<"publishing.publishEntry">;
+type PublishingRevertChangesError = OperationError<"publishing.revertChanges">;
+type PublishingRevertChangesInput = OperationInput<"publishing.revertChanges">;
+type PublishingRevertChangesOutput = OperationOutput<"publishing.revertChanges">;
+type PublishingSetCollectionError = OperationError<"publishing.setCollection">;
+type PublishingSetCollectionInput = OperationInput<"publishing.setCollection">;
+type PublishingSetCollectionOutput = OperationOutput<"publishing.setCollection">;
+type PublishingUnpublishCollectionError = OperationError<"publishing.unpublishCollection">;
+type PublishingUnpublishCollectionInput = OperationInput<"publishing.unpublishCollection">;
+type PublishingUnpublishCollectionOutput = OperationOutput<"publishing.unpublishCollection">;
+type PublishingUnpublishEntryError = OperationError<"publishing.unpublishEntry">;
+type PublishingUnpublishEntryInput = OperationInput<"publishing.unpublishEntry">;
+type PublishingUnpublishEntryOutput = OperationOutput<"publishing.unpublishEntry">;
+type RolesCreateError = OperationError<"roles.create">;
+type RolesCreateInput = OperationInput<"roles.create">;
+type RolesCreateOutput = OperationOutput<"roles.create">;
+type RolesDeleteError = OperationError<"roles.delete">;
+type RolesDeleteInput = OperationInput<"roles.delete">;
+type RolesDeleteOutput = OperationOutput<"roles.delete">;
+type RolesListError = OperationError<"roles.list">;
+type RolesListInput = OperationInput<"roles.list">;
+type RolesListOutput = OperationOutput<"roles.list">;
+type RolesUpdateError = OperationError<"roles.update">;
+type RolesUpdateInput = OperationInput<"roles.update">;
+type RolesUpdateOutput = OperationOutput<"roles.update">;
+type SchemaMigrationsGetActiveError = OperationError<"schemaMigrations.getActive">;
+type SchemaMigrationsGetActiveInput = OperationInput<"schemaMigrations.getActive">;
+type SchemaMigrationsGetActiveOutput = OperationOutput<"schemaMigrations.getActive">;
+type SchemaMigrationsGetError = OperationError<"schemaMigrations.get">;
+type SchemaMigrationsGetInput = OperationInput<"schemaMigrations.get">;
+type SchemaMigrationsGetOutput = OperationOutput<"schemaMigrations.get">;
+type SchemaMigrationsListContentLossEntriesError = OperationError<"schemaMigrations.listContentLossEntries">;
+type SchemaMigrationsListContentLossEntriesInput = OperationInput<"schemaMigrations.listContentLossEntries">;
+type SchemaMigrationsListContentLossEntriesOutput = OperationOutput<"schemaMigrations.listContentLossEntries">;
+type SchemaVersionsGetError = OperationError<"schemaVersions.get">;
+type SchemaVersionsGetInput = OperationInput<"schemaVersions.get">;
+type SchemaVersionsGetOutput = OperationOutput<"schemaVersions.get">;
+type SchemaVersionsListError = OperationError<"schemaVersions.list">;
+type SchemaVersionsListInput = OperationInput<"schemaVersions.list">;
+type SchemaVersionsListOutput = OperationOutput<"schemaVersions.list">;
+type SchemaVersionsRevertError = OperationError<"schemaVersions.revert">;
+type SchemaVersionsRevertInput = OperationInput<"schemaVersions.revert">;
+type SchemaVersionsRevertOutput = OperationOutput<"schemaVersions.revert">;
+type SchemaVersionsUpdateError = OperationError<"schemaVersions.update">;
+type SchemaVersionsUpdateInput = OperationInput<"schemaVersions.update">;
+type SchemaVersionsUpdateOutput = OperationOutput<"schemaVersions.update">;
+type SchemasApplyError = OperationError<"schemas.apply">;
+type SchemasApplyInput = OperationInput<"schemas.apply">;
+type SchemasApplyOutput = OperationOutput<"schemas.apply">;
+type SchemasCreateError = OperationError<"schemas.create">;
+type SchemasCreateInput = OperationInput<"schemas.create">;
+type SchemasCreateOutput = OperationOutput<"schemas.create">;
+type SchemasDeleteError = OperationError<"schemas.delete">;
+type SchemasDeleteInput = OperationInput<"schemas.delete">;
+type SchemasDeleteOutput = OperationOutput<"schemas.delete">;
+type SchemasGetError = OperationError<"schemas.get">;
+type SchemasGetInput = OperationInput<"schemas.get">;
+type SchemasGetOutput = OperationOutput<"schemas.get">;
+type SchemasGetRevisionError = OperationError<"schemas.getRevision">;
+type SchemasGetRevisionInput = OperationInput<"schemas.getRevision">;
+type SchemasGetRevisionOutput = OperationOutput<"schemas.getRevision">;
+type SearchAskCurrentError = OperationError<"search.askCurrent">;
+type SearchAskCurrentInput = OperationInput<"search.askCurrent">;
+type SearchAskCurrentOutput = OperationOutput<"search.askCurrent">;
+type SearchAskCurrentStreamError = OperationError<"search.askCurrentStream">;
+type SearchAskCurrentStreamInput = OperationInput<"search.askCurrentStream">;
+type SearchAskCurrentStreamOutput = OperationOutput<"search.askCurrentStream">;
+type SearchAskPublishedError = OperationError<"search.askPublished">;
+type SearchAskPublishedInput = OperationInput<"search.askPublished">;
+type SearchAskPublishedOutput = OperationOutput<"search.askPublished">;
+type SearchAskPublishedStreamError = OperationError<"search.askPublishedStream">;
+type SearchAskPublishedStreamInput = OperationInput<"search.askPublishedStream">;
+type SearchAskPublishedStreamOutput = OperationOutput<"search.askPublishedStream">;
+type SearchCurrentError = OperationError<"search.current">;
+type SearchCurrentInput = OperationInput<"search.current">;
+type SearchCurrentOutput = OperationOutput<"search.current">;
+type SearchPublishedError = OperationError<"search.published">;
+type SearchPublishedInput = OperationInput<"search.published">;
+type SearchPublishedOutput = OperationOutput<"search.published">;
+type TypeMetadataGetCurrentError = OperationError<"typeMetadata.getCurrent">;
+type TypeMetadataGetCurrentInput = OperationInput<"typeMetadata.getCurrent">;
+type TypeMetadataGetCurrentOutput = OperationOutput<"typeMetadata.getCurrent">;
+type TypeMetadataGetPublishedError = OperationError<"typeMetadata.getPublished">;
+type TypeMetadataGetPublishedInput = OperationInput<"typeMetadata.getPublished">;
+type TypeMetadataGetPublishedOutput = OperationOutput<"typeMetadata.getPublished">;
+type VersionsCreateError = OperationError<"versions.create">;
+type VersionsCreateInput = OperationInput<"versions.create">;
+type VersionsCreateOutput = OperationOutput<"versions.create">;
+type VersionsGetError = OperationError<"versions.get">;
+type VersionsGetInput = OperationInput<"versions.get">;
+type VersionsGetOutput = OperationOutput<"versions.get">;
+type VersionsListError = OperationError<"versions.list">;
+type VersionsListInput = OperationInput<"versions.list">;
+type VersionsListOutput = OperationOutput<"versions.list">;
+type VersionsRevertError = OperationError<"versions.revert">;
+type VersionsRevertInput = OperationInput<"versions.revert">;
+type VersionsRevertOutput = OperationOutput<"versions.revert">;
+type VersionsUpdateError = OperationError<"versions.update">;
+type VersionsUpdateInput = OperationInput<"versions.update">;
+type VersionsUpdateOutput = OperationOutput<"versions.update">;
+type WebhooksBulkDeleteError = OperationError<"webhooks.bulkDelete">;
+type WebhooksBulkDeleteInput = OperationInput<"webhooks.bulkDelete">;
+type WebhooksBulkDeleteOutput = OperationOutput<"webhooks.bulkDelete">;
+type WebhooksBulkRedeliverError = OperationError<"webhooks.bulkRedeliver">;
+type WebhooksBulkRedeliverInput = OperationInput<"webhooks.bulkRedeliver">;
+type WebhooksBulkRedeliverOutput = OperationOutput<"webhooks.bulkRedeliver">;
+type WebhooksBulkSetEnabledError = OperationError<"webhooks.bulkSetEnabled">;
+type WebhooksBulkSetEnabledInput = OperationInput<"webhooks.bulkSetEnabled">;
+type WebhooksBulkSetEnabledOutput = OperationOutput<"webhooks.bulkSetEnabled">;
+type WebhooksCreateError = OperationError<"webhooks.create">;
+type WebhooksCreateInput = OperationInput<"webhooks.create">;
+type WebhooksCreateOutput = OperationOutput<"webhooks.create">;
+type WebhooksDeleteError = OperationError<"webhooks.delete">;
+type WebhooksDeleteInput = OperationInput<"webhooks.delete">;
+type WebhooksDeleteOutput = OperationOutput<"webhooks.delete">;
+type WebhooksGetDeliveryError = OperationError<"webhooks.getDelivery">;
+type WebhooksGetDeliveryInput = OperationInput<"webhooks.getDelivery">;
+type WebhooksGetDeliveryOutput = OperationOutput<"webhooks.getDelivery">;
+type WebhooksGetError = OperationError<"webhooks.get">;
+type WebhooksGetInput = OperationInput<"webhooks.get">;
+type WebhooksGetOutput = OperationOutput<"webhooks.get">;
+type WebhooksListAttemptsError = OperationError<"webhooks.listAttempts">;
+type WebhooksListAttemptsInput = OperationInput<"webhooks.listAttempts">;
+type WebhooksListAttemptsOutput = OperationOutput<"webhooks.listAttempts">;
+type WebhooksListDeliveriesError = OperationError<"webhooks.listDeliveries">;
+type WebhooksListDeliveriesInput = OperationInput<"webhooks.listDeliveries">;
+type WebhooksListDeliveriesOutput = OperationOutput<"webhooks.listDeliveries">;
+type WebhooksListError = OperationError<"webhooks.list">;
+type WebhooksListInput = OperationInput<"webhooks.list">;
+type WebhooksListOutput = OperationOutput<"webhooks.list">;
+type WebhooksListRunsError = OperationError<"webhooks.listRuns">;
+type WebhooksListRunsInput = OperationInput<"webhooks.listRuns">;
+type WebhooksListRunsOutput = OperationOutput<"webhooks.listRuns">;
+type WebhooksRedeliverError = OperationError<"webhooks.redeliver">;
+type WebhooksRedeliverInput = OperationInput<"webhooks.redeliver">;
+type WebhooksRedeliverOutput = OperationOutput<"webhooks.redeliver">;
+type WebhooksRotateSecretError = OperationError<"webhooks.rotateSecret">;
+type WebhooksRotateSecretInput = OperationInput<"webhooks.rotateSecret">;
+type WebhooksRotateSecretOutput = OperationOutput<"webhooks.rotateSecret">;
+type WebhooksSendTestError = OperationError<"webhooks.sendTest">;
+type WebhooksSendTestInput = OperationInput<"webhooks.sendTest">;
+type WebhooksSendTestOutput = OperationOutput<"webhooks.sendTest">;
+type WebhooksUpdateError = OperationError<"webhooks.update">;
+type WebhooksUpdateInput = OperationInput<"webhooks.update">;
+type WebhooksUpdateOutput = OperationOutput<"webhooks.update">;
+type WorkspacesListError = OperationError<"workspaces.list">;
+type WorkspacesListInput = OperationInput<"workspaces.list">;
+type WorkspacesListOutput = OperationOutput<"workspaces.list">;
+//#endregion
+//#region src/paginate.d.ts
+interface Page<T> {
+  data: T[];
+  pagination: {
+    nextCursor: string | null;
+    hasMore: boolean;
+  };
+}
+interface PaginateOptions {
+  /** Start after a saved cursor. The callback must retain its original scope and snapshot. */
+  cursor?: string;
+}
+/**
+ * Iterate cursor-paginated pages, retaining their metadata.
+ *
+ * @param getPage - Fetch one page for the supplied cursor. The first cursor is undefined unless supplied.
+ * Keep filters stable. This generic helper does not bind snapshots; use content.paginateEntryPages()
+ * or content.paginateCollectionPages() for automatic published snapshot handling.
+ * @param options - Optional cursor from an earlier page to resume processing.
+ * @returns A lazy iterator that requests the next page only after the previous page is consumed.
+ * Save pagination.nextCursor after processing a page. Break the loop to stop further requests.
+ * @throws Error for a missing or repeated next cursor. Callback failures pass through unchanged.
+ */
+declare const paginatePages: <P extends Page<unknown>>(getPage: (cursor?: string) => Promise<P>, options?: PaginateOptions) => AsyncGenerator<P>;
+/**
+ * Iterate items across cursor-paginated pages without collecting them in memory.
+ *
+ * @param getPage - Fetch one page using the cursor. Keep scope and filters stable in this callback.
+ * This generic helper does not bind snapshots; content.paginateEntries() and
+ * content.paginateCollections() do that automatically for published content.
+ * @param options - Optional starting cursor; retain its matching scope and snapshot yourself.
+ * @returns Items in API order. Break the loop to prevent further page requests.
+ * @throws Pagination errors from paginatePages(), or the original callback error.
+ */
+declare const paginate: <T>(getPage: (cursor?: string) => Promise<Page<T>>, options?: PaginateOptions) => AsyncGenerator<T>;
+//#endregion
+//#region src/structured-content.d.ts
+interface StructuredContentSource {
+  properties: Readonly<Record<string, {
+    readonly value: unknown;
+  } | undefined>>;
+  fragments: Readonly<Record<string, {
+    readonly content: unknown;
+  } | undefined>>;
+}
+type PropertyValue<T> = T extends {
+  readonly value: infer Value;
+} ? Value : undefined;
+type FragmentContent<T> = T extends {
+  readonly content: infer Content;
+} ? Content : undefined;
+type StructuredContent<T extends StructuredContentSource> = T extends unknown ? Omit<T, "properties" | "fragments"> & {
+  properties: { [Key in keyof T["properties"]]: PropertyValue<T["properties"][Key]>; };
+  fragments: { [Key in keyof T["fragments"]]: FragmentContent<T["fragments"][Key]>; };
+} : never;
+/**
+ * Unwrap property values and fragment documents for use in application code.
+ *
+ * @param page - Full entry content with properties and fragments, including published list items.
+ * @returns A new object with property.value and fragment.content exposed by key. Other fields,
+ * including schema metadata and assets, are preserved. Nested content is shared, not cloned.
+ * Workspace field types and revision unions are preserved. This helper does not validate content or convert formats.
+ * @example
+ * const tutorial = toStructuredContent(page);
+ * const body = tutorial.fragments.body;
+ * const enabled = tutorial.properties.enabled;
+ */
+declare const toStructuredContent: <T extends StructuredContentSource>(page: T) => StructuredContent<T>;
+//#endregion
+export { ContentGetTreeError as $, WebhooksListError as $i, RolesListError as $n, SearchCurrentError as $r, PublishingBulkPublishEntriesError as $t, CollectionsBulkDeleteInput as A, ContentClient as Aa, WebhooksBulkRedeliverInput as Ai, PublishingPublishCollectionInput as An, SchemasCreateInput as Ar, MembershipsInviteInput as At, CollectionsListOutput as B, RequestOptions as Ba, WebhooksDeleteOutput as Bi, PublishingSetCollectionOutput as Bn, SchemasGetRevisionOutput as Br, MembershipsRemoveOutput as Bt, AssetsUploadError as C, AndesineStreamProtocolError as Ca, VersionsUpdateError as Ci, PublishingListChannelsError as Cn, SchemaVersionsUpdateError as Cr, EntriesUpdateError as Ct, AuthGetIdentityInput as D, AndesineClient as Da, WebhooksBulkDeleteInput as Di, PublishingListEntryPublicationsInput as Dn, SchemasApplyInput as Dr, InstanceGetInput as Dt, AuthGetIdentityError as E, toContentURL as Ea, WebhooksBulkDeleteError as Ei, PublishingListEntryPublicationsError as En, SchemasApplyError as Er, InstanceGetError as Et, CollectionsDeleteError as F, APIResponse as Fa, WebhooksCreateError as Fi, PublishingRevertChangesError as Fn, SchemasGetError as Fr, MembershipsListInvitesInput as Ft, ContentGetAssetInput as G, WorkspaceSchema as Ga, WebhooksGetInput as Gi, PublishingUnpublishEntryInput as Gn, SearchAskCurrentStreamInput as Gr, MembershipsRevokeInviteInput as Gt, CollectionsUpdateInput as H, SchemaContent as Ha, WebhooksGetDeliveryInput as Hi, PublishingUnpublishCollectionInput as Hn, SearchAskCurrentInput as Hr, MembershipsResendInviteInput as Ht, CollectionsDeleteInput as I, NotModifiedResponse as Ia, WebhooksCreateInput as Ii, PublishingRevertChangesInput as In, SchemasGetInput as Ir, MembershipsListInvitesOutput as It, ContentGetInput as J, WebhooksListAttemptsInput as Ji, RolesCreateInput as Jn, SearchAskPublishedInput as Jr, MembershipsUpdateInput as Jt, ContentGetAssetOutput as K, WorkspaceTypeMap as Ka, WebhooksGetOutput as Ki, PublishingUnpublishEntryOutput as Kn, SearchAskCurrentStreamOutput as Kr, MembershipsRevokeInviteOutput as Kt, CollectionsDeleteOutput as L, OperationError as La, WebhooksCreateOutput as Li, PublishingRevertChangesOutput as Ln, SchemasGetOutput as Lr, MembershipsListOutput as Lt, CollectionsCreateError as M, APIErrorBody as Ma, WebhooksBulkSetEnabledError as Mi, PublishingPublishEntryError as Mn, SchemasDeleteError as Mr, MembershipsListError as Mt, CollectionsCreateInput as N, APIErrorCode as Na, WebhooksBulkSetEnabledInput as Ni, PublishingPublishEntryInput as Nn, SchemasDeleteInput as Nr, MembershipsListInput as Nt, AuthGetIdentityOutput as O, ClientOptions as Oa, WebhooksBulkDeleteOutput as Oi, PublishingListEntryPublicationsOutput as On, SchemasApplyOutput as Or, InstanceGetOutput as Ot, CollectionsCreateOutput as P, APIErrorData as Pa, WebhooksBulkSetEnabledOutput as Pi, PublishingPublishEntryOutput as Pn, SchemasDeleteOutput as Pr, MembershipsListInvitesError as Pt, ContentGetSchemaOutput as Q, WebhooksListDeliveriesOutput as Qi, RolesDeleteOutput as Qn, SearchAskPublishedStreamOutput as Qr, PublishingBulkPublishCollectionsOutput as Qt, CollectionsListError as R, OperationInput as Ra, WebhooksDeleteError as Ri, PublishingSetCollectionError as Rn, SchemasGetRevisionError as Rr, MembershipsRemoveError as Rt, AssetsSearchOutput as S, AndesineStreamError as Sa, VersionsRevertOutput as Si, PublishingGetEntryVersionOutput as Sn, SchemaVersionsRevertOutput as Sr, EntriesListOutput as St, AssetsUploadOutput as T, ContentURLOptions as Ta, VersionsUpdateOutput as Ti, PublishingListChannelsOutput as Tn, SchemaVersionsUpdateOutput as Tr, EntriesUpdateOutput as Tt, CollectionsUpdateOutput as U, WorkspaceCollection as Ua, WebhooksGetDeliveryOutput as Ui, PublishingUnpublishCollectionOutput as Un, SearchAskCurrentOutput as Ur, MembershipsResendInviteOutput as Ut, CollectionsUpdateError as V, ContentListOutput as Va, WebhooksGetDeliveryError as Vi, PublishingUnpublishCollectionError as Vn, SearchAskCurrentError as Vr, MembershipsResendInviteError as Vt, ContentGetAssetError as W, WorkspaceEntry as Wa, WebhooksGetError as Wi, PublishingUnpublishEntryError as Wn, SearchAskCurrentStreamError as Wr, MembershipsRevokeInviteError as Wt, ContentGetSchemaError as X, WebhooksListDeliveriesError as Xi, RolesDeleteError as Xn, SearchAskPublishedStreamError as Xr, PublishingBulkPublishCollectionsError as Xt, ContentGetOutput as Y, WebhooksListAttemptsOutput as Yi, RolesCreateOutput as Yn, SearchAskPublishedOutput as Yr, MembershipsUpdateOutput as Yt, ContentGetSchemaInput as Z, WebhooksListDeliveriesInput as Zi, RolesDeleteInput as Zn, SearchAskPublishedStreamInput as Zr, PublishingBulkPublishCollectionsInput as Zt, AssetsRegisterError as _, WorkspacesListError as _a, VersionsListError as _i, PublishingGetChannelContentError as _n, SchemaVersionsListError as _r, EntriesGetError as _t, PaginateOptions as a, WebhooksRedeliverError as aa, TypeMetadataGetCurrentError as ai, PublishingBulkUnpublishCollectionsError as an, SchemaMigrationsGetActiveError as ar, ContentListEntriesError as at, AssetsSearchError as b, types_d_exports as ba, VersionsRevertError as bi, PublishingGetEntryVersionError as bn, SchemaVersionsRevertError as br, EntriesListError as bt, AssetsAttachError as c, WebhooksRotateSecretError as ca, TypeMetadataGetPublishedError as ci, PublishingBulkUnpublishEntriesError as cn, SchemaMigrationsGetError as cr, EntriesBulkDeleteError as ct, AssetsGetError as d, WebhooksSendTestError as da, VersionsCreateError as di, PublishingCreateChannelError as dn, SchemaMigrationsListContentLossEntriesError as dr, EntriesCreateError as dt, WebhooksListInput as ea, SearchCurrentInput as ei, PublishingBulkPublishEntriesInput as en, RolesListInput as er, ContentGetTreeInput as et, AssetsGetInput as f, WebhooksSendTestInput as fa, VersionsCreateInput as fi, PublishingCreateChannelInput as fn, SchemaMigrationsListContentLossEntriesInput as fr, EntriesCreateInput as ft, AssetsImportURLOutput as g, WebhooksUpdateOutput as ga, VersionsGetOutput as gi, PublishingDeleteChannelOutput as gn, SchemaVersionsGetOutput as gr, EntriesDeleteOutput as gt, AssetsImportURLInput as h, WebhooksUpdateInput as ha, VersionsGetInput as hi, PublishingDeleteChannelInput as hn, SchemaVersionsGetInput as hr, EntriesDeleteInput as ht, Page as i, WebhooksListRunsOutput as ia, SearchPublishedOutput as ii, PublishingBulkSetCollectionsOutput as in, RolesUpdateOutput as ir, ContentListCollectionsOutput as it, CollectionsBulkDeleteOutput as j, ContentPaginationOptions as ja, WebhooksBulkRedeliverOutput as ji, PublishingPublishCollectionOutput as jn, SchemasCreateOutput as jr, MembershipsInviteOutput as jt, CollectionsBulkDeleteError as k, createClient as ka, WebhooksBulkRedeliverError as ki, PublishingPublishCollectionError as kn, SchemasCreateError as kr, MembershipsInviteError as kt, AssetsAttachInput as l, WebhooksRotateSecretInput as la, TypeMetadataGetPublishedInput as li, PublishingBulkUnpublishEntriesInput as ln, SchemaMigrationsGetInput as lr, EntriesBulkDeleteInput as lt, AssetsImportURLError as m, WebhooksUpdateError as ma, VersionsGetError as mi, PublishingDeleteChannelError as mn, SchemaVersionsGetError as mr, EntriesDeleteError as mt, StructuredContentSource as n, WebhooksListRunsError as na, SearchPublishedError as ni, PublishingBulkSetCollectionsError as nn, RolesUpdateError as nr, ContentListCollectionsError as nt, paginate as o, WebhooksRedeliverInput as oa, TypeMetadataGetCurrentInput as oi, PublishingBulkUnpublishCollectionsInput as on, SchemaMigrationsGetActiveInput as or, ContentListEntriesInput as ot, AssetsGetOutput as p, WebhooksSendTestOutput as pa, VersionsCreateOutput as pi, PublishingCreateChannelOutput as pn, SchemaMigrationsListContentLossEntriesOutput as pr, EntriesCreateOutput as pt, ContentGetError as q, WebhooksListAttemptsError as qi, RolesCreateError as qn, SearchAskPublishedError as qr, MembershipsUpdateError as qt, toStructuredContent as r, WebhooksListRunsInput as ra, SearchPublishedInput as ri, PublishingBulkSetCollectionsInput as rn, RolesUpdateInput as rr, ContentListCollectionsInput as rt, paginatePages as s, WebhooksRedeliverOutput as sa, TypeMetadataGetCurrentOutput as si, PublishingBulkUnpublishCollectionsOutput as sn, SchemaMigrationsGetActiveOutput as sr, ContentListEntriesOutput as st, StructuredContent as t, WebhooksListOutput as ta, SearchCurrentOutput as ti, PublishingBulkPublishEntriesOutput as tn, RolesListOutput as tr, ContentGetTreeOutput as tt, AssetsAttachOutput as u, WebhooksRotateSecretOutput as ua, TypeMetadataGetPublishedOutput as ui, PublishingBulkUnpublishEntriesOutput as un, SchemaMigrationsGetOutput as ur, EntriesBulkDeleteOutput as ut, AssetsRegisterInput as v, WorkspacesListInput as va, VersionsListInput as vi, PublishingGetChannelContentInput as vn, SchemaVersionsListInput as vr, EntriesGetInput as vt, AssetsUploadInput as w, ContentLocation as wa, VersionsUpdateInput as wi, PublishingListChannelsInput as wn, SchemaVersionsUpdateInput as wr, EntriesUpdateInput as wt, AssetsSearchInput as x, AndesineAPIError as xa, VersionsRevertInput as xi, PublishingGetEntryVersionInput as xn, SchemaVersionsRevertInput as xr, EntriesListInput as xt, AssetsRegisterOutput as y, WorkspacesListOutput as ya, VersionsListOutput as yi, PublishingGetChannelContentOutput as yn, SchemaVersionsListOutput as yr, EntriesGetOutput as yt, CollectionsListInput as z, OperationOutput as za, WebhooksDeleteInput as zi, PublishingSetCollectionInput as zn, SchemasGetRevisionInput as zr, MembershipsRemoveInput as zt };
+//# sourceMappingURL=index-moj3WP71.d.ts.map