@andesine/sdk 0.1.0 → 0.5.0

package/dist/client-C8wt7f3o.d.ts

@@ -0,0 +1,1596 @@
+import { N as ContentSchemaMetadata, R as EntryFragment, _n as operations, gn as components, mt as PublishedCollection, yt as PublishedEntryContent, z as EntryProperty } from "./schema-CrquN_J6.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>;
+  };
+  extensions: {
+    /**
+     * Get the extension
+     *
+     * Returns the installed extension that the token's subject names, including disabled and uninstalled extensions.
+     */
+    getSelf: Operation<"extensions.getSelf", Workspace>;
+    /**
+     * Verify a session token
+     *
+     * Verifies a session token from the extension frontend and returns its member. Tokens of other extensions, expired tokens, and tokens of an earlier extension generation fail with NOT_FOUND.
+     */
+    verifySession: Operation<"extensions.verifySession", Workspace>;
+    /**
+     * List installations
+     *
+     * Lists the installations of the extension on this instance. Requires an app-level token: an extension JWT without a subject.
+     */
+    listInstallations: Operation<"extensions.listInstallations", Workspace>;
+    /**
+     * Get a delivery
+     *
+     * Returns the event of a delivery to one of the extension's webhooks. Disabled and uninstalled extensions can read only lifecycle deliveries.
+     */
+    getSelfDelivery: Operation<"extensions.getSelfDelivery", Workspace>;
+    /**
+     * Get the configuration
+     *
+     * Returns the extension's configuration, including secret fields, and its revision. Unset fields use their defaults.
+     */
+    getSelfConfiguration: Operation<"extensions.getSelfConfiguration", Workspace>;
+    /**
+     * Get a storage entry
+     *
+     * Returns an entry of the extension's storage, or NOT_FOUND.
+     */
+    getSelfStorageEntry: Operation<"extensions.getSelfStorageEntry", Workspace>;
+    /**
+     * Set a storage entry
+     *
+     * Creates or replaces an entry of the extension's storage. Values are JSON up to 128 KiB; the storage holds up to 10,000 entries and 10 MiB.
+     */
+    setSelfStorageEntry: Operation<"extensions.setSelfStorageEntry", Workspace>;
+    /**
+     * Delete a storage entry
+     *
+     * Deletes an entry of the extension's storage, if it exists.
+     */
+    deleteSelfStorageEntry: Operation<"extensions.deleteSelfStorageEntry", Workspace>;
+    /**
+     * List storage entries
+     *
+     * Lists the extension's storage entries in key order, optionally with a key prefix. A page ends early when its values reach 192 KiB.
+     */
+    listSelfStorageEntries: Operation<"extensions.listSelfStorageEntries", 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
+export { WorkspaceCollection as _, ContentPaginationOptions as a, WorkspaceTypeMap as b, APIErrorData as c, OperationError as d, OperationInput as f, SchemaContent as g, ContentListOutput as h, ContentClient as i, APIResponse as l, RequestOptions as m, ClientOptions as n, APIErrorBody as o, OperationOutput as p, createClient as r, APIErrorCode as s, AndesineClient as t, NotModifiedResponse as u, WorkspaceEntry as v, WorkspaceSchema as y };
+//# sourceMappingURL=client-C8wt7f3o.d.ts.map