@prism-draft/sdk 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1926 @@
+// src/client.ts
+import createOpenApiClient from "openapi-fetch";
+
+// src/generated/resources.ts
+class ApiKeys {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/api-keys", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/api-keys", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async revoke(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/api-keys/{keyId}", {
+      params: { path: { workspaceId: input.workspaceId, keyId: input.keyId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async rotate(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/api-keys/{keyId}/rotate", {
+      params: { path: { workspaceId: input.workspaceId, keyId: input.keyId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class ArticleGroups {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/article-groups", {
+      params: { query: { workspaceId: input.workspaceId, projectId: input.projectId, categoryId: input.categoryId, category: input.category, status: input.status, language: input.language, q: input.q, createdBy: input.createdBy, limit: input.limit, offset: input.offset } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async get(input, init) {
+    const { data } = await this.client.GET("/api/article-groups/{translationGroupId}", {
+      params: { path: { translationGroupId: input.translationGroupId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/article-groups/{translationGroupId}", {
+      params: { path: { translationGroupId: input.translationGroupId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async approve(input, init) {
+    const { data } = await this.client.POST("/api/article-groups/{translationGroupId}/approve", {
+      params: { path: { translationGroupId: input.translationGroupId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async publish(input, init) {
+    const { data } = await this.client.POST("/api/article-groups/{translationGroupId}/publish", {
+      params: { path: { translationGroupId: input.translationGroupId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async unpublish(input, init) {
+    const { data } = await this.client.POST("/api/article-groups/{translationGroupId}/unpublish", {
+      params: { path: { translationGroupId: input.translationGroupId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Articles {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/articles", {
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/articles", {
+      params: { query: { workspaceId: input.workspaceId, projectId: input.projectId, categoryId: input.categoryId, category: input.category, status: input.status, language: input.language, slug: input.slug, q: input.q, createdBy: input.createdBy, limit: input.limit, offset: input.offset } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async duplicate(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/duplicate", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async get(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}", {
+      params: { path: { articleId: input.articleId }, query: { stripLead: input.stripLead } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/articles/{articleId}", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/articles/{articleId}", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async submit(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/submit", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async approve(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/approve", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async reject(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/reject", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async requestChanges(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/request-changes", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async publish(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/publish", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async unpublish(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/unpublish", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async transitionTranslations(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/translations/{action}", {
+      params: { path: { articleId: input.articleId, action: input.action } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listReviews(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/reviews", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listVersions(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/versions", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getVersion(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/versions/{version}", {
+      params: { path: { articleId: input.articleId, version: input.version } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getSources(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/sources", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async restoreVersion(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/versions/{version}/restore", {
+      params: { path: { articleId: input.articleId, version: input.version } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listComments(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/comments", {
+      params: { path: { articleId: input.articleId }, query: { status: input.status } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async addComment(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/comments", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async resolveComment(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/comments/{commentId}/resolve", {
+      params: { path: { articleId: input.articleId, commentId: input.commentId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async reopenComment(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/comments/{commentId}/reopen", {
+      params: { path: { articleId: input.articleId, commentId: input.commentId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async checkDuplicates(input, init) {
+    const { data } = await this.client.GET("/api/projects/{projectId}/duplicate-check", {
+      params: { path: { projectId: input.projectId }, query: { title: input.title, slug: input.slug, language: input.language } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async setHeroFromUrl(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/hero", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async setHeroFromFile(input, init) {
+    const { data } = await this.client.PUT("/api/articles/{articleId}/hero/file", {
+      params: { path: { articleId: input.articleId }, query: { altText: input.altText } },
+      body: input.body,
+      bodySerializer: (body) => body,
+      headers: { "content-type": input.contentType },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async detachHeroFromBody(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/hero/detach-from-body", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Billing {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async listCreditPackages(init) {
+    const { data } = await this.client.GET("/api/credit-packages", {
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getCredits(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/credits", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async adjustCredits(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/credits/adjust", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listPlans(init) {
+    const { data } = await this.client.GET("/api/plans", {
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getSubscription(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/subscription", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async startSubscriptionCheckout(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/subscription/checkout", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async openPortal(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/subscription/portal", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async startCheckout(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/checkout", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Blog {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async listPosts(input, init) {
+    const { data } = await this.client.GET("/api/blog/posts", {
+      params: { query: { locale: input.locale, limit: input.limit, offset: input.offset, category: input.category } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listCategories(input, init) {
+    const { data } = await this.client.GET("/api/blog/categories", {
+      params: { query: { locale: input.locale } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getPost(input, init) {
+    const { data } = await this.client.GET("/api/blog/posts/{slug}", {
+      params: { path: { slug: input.slug }, query: { language: input.language } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getPostEdit(input, init) {
+    const { data } = await this.client.GET("/api/blog/posts/{slug}/edit", {
+      params: { path: { slug: input.slug }, query: { language: input.language } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class BrandVoices {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/brand-voices", {
+      params: { path: { workspaceId: input.workspaceId }, query: { projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/brand-voices", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/brand-voices/{voiceId}", {
+      params: { path: { workspaceId: input.workspaceId, voiceId: input.voiceId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/brand-voices/{voiceId}", {
+      params: { path: { workspaceId: input.workspaceId, voiceId: input.voiceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Briefs {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async draft(input, init) {
+    const { data } = await this.client.POST("/api/projects/{projectId}/brief", {
+      params: { path: { projectId: input.projectId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/projects/{projectId}/briefs", {
+      params: { path: { projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/projects/{projectId}/briefs", {
+      params: { path: { projectId: input.projectId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async get(input, init) {
+    const { data } = await this.client.GET("/api/briefs/{briefId}", {
+      params: { path: { briefId: input.briefId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/briefs/{briefId}", {
+      params: { path: { briefId: input.briefId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/briefs/{briefId}", {
+      params: { path: { briefId: input.briefId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Calendar {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/calendar", {
+      params: { path: { workspaceId: input.workspaceId }, query: { from: input.from, to: input.to } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/calendar", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/calendar/{itemId}", {
+      params: { path: { workspaceId: input.workspaceId, itemId: input.itemId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/calendar/{itemId}", {
+      params: { path: { workspaceId: input.workspaceId, itemId: input.itemId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Categories {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/categories", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/categories", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/categories/{categoryId}", {
+      params: { path: { workspaceId: input.workspaceId, categoryId: input.categoryId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/categories/{categoryId}", {
+      params: { path: { workspaceId: input.workspaceId, categoryId: input.categoryId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async setForArticle(input, init) {
+    const { data } = await this.client.PUT("/api/articles/{articleId}/categories", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async suggestForArticle(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/categories/suggest", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async suggestForProject(input, init) {
+    const { data } = await this.client.POST("/api/projects/{projectId}/categories/suggest", {
+      params: { path: { projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async translate(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/categories/{categoryId}/translate", {
+      params: { path: { workspaceId: input.workspaceId, categoryId: input.categoryId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class ContentTemplates {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/content-templates", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/content-templates", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/content-templates/{templateId}", {
+      params: { path: { workspaceId: input.workspaceId, templateId: input.templateId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/content-templates/{templateId}", {
+      params: { path: { workspaceId: input.workspaceId, templateId: input.templateId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Dashboard {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async getAnalytics(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/analytics", {
+      params: { path: { workspaceId: input.workspaceId }, query: { days: input.days } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getTrends(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/trends", {
+      params: { path: { workspaceId: input.workspaceId }, query: { days: input.days } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getArticleCounts(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/article-counts", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listJobs(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/jobs", {
+      params: { path: { workspaceId: input.workspaceId }, query: { limit: input.limit, failedWithinDays: input.failedWithinDays } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listAudit(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/audit", {
+      params: { path: { workspaceId: input.workspaceId }, query: { limit: input.limit, offset: input.offset, action: input.action, actorId: input.actorId, from: input.from, to: input.to } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getCreditBurn(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/credit-burn", {
+      params: { path: { workspaceId: input.workspaceId }, query: { days: input.days } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Generation {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async estimate(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/estimate", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getOutline(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/outline", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async approveOutline(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/outline/approve", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async aiEdit(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/ai-edit", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async start(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/generate", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async getStatus(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/status", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async cancel(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/cancel", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async regenerateImage(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/regenerate-image", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async updateAsset(input, init) {
+    const { data } = await this.client.PATCH("/api/articles/{articleId}/assets/{assetId}", {
+      params: { path: { articleId: input.articleId, assetId: input.assetId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async deleteAsset(input, init) {
+    const { data } = await this.client.DELETE("/api/articles/{articleId}/assets/{assetId}", {
+      params: { path: { articleId: input.articleId, assetId: input.assetId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Ideas {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/ideas", {
+      params: { path: { workspaceId: input.workspaceId }, query: { projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/ideas", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/ideas/{ideaId}", {
+      params: { path: { workspaceId: input.workspaceId, ideaId: input.ideaId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/ideas/{ideaId}", {
+      params: { path: { workspaceId: input.workspaceId, ideaId: input.ideaId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async generate(input, init) {
+    const { data } = await this.client.POST("/api/projects/{projectId}/ideas/generate", {
+      params: { path: { projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Integrations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/integrations", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/integrations", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/integrations/{integrationId}", {
+      params: { path: { workspaceId: input.workspaceId, integrationId: input.integrationId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/integrations/{integrationId}", {
+      params: { path: { workspaceId: input.workspaceId, integrationId: input.integrationId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Invitations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/invitations", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async revoke(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/invitations/{invitationId}", {
+      params: { path: { workspaceId: input.workspaceId, invitationId: input.invitationId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async resend(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/invitations/{invitationId}/resend", {
+      params: { path: { workspaceId: input.workspaceId, invitationId: input.invitationId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Knowledge {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/projects/{projectId}/knowledge", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/projects/{projectId}/knowledge", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async uploadContent(input, init) {
+    const { data } = await this.client.PUT("/api/workspaces/{workspaceId}/knowledge/{sourceId}/content", {
+      params: { path: { workspaceId: input.workspaceId, sourceId: input.sourceId } },
+      body: input.body,
+      bodySerializer: (body) => body,
+      headers: { "content-type": input.contentType },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async reingest(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/knowledge/{sourceId}/reingest", {
+      params: { path: { workspaceId: input.workspaceId, sourceId: input.sourceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/knowledge/{sourceId}", {
+      params: { path: { workspaceId: input.workspaceId, sourceId: input.sourceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Links {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/links", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async generate(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/links", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async decide(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/links/{suggestionId}", {
+      params: { path: { workspaceId: input.workspaceId, suggestionId: input.suggestionId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Permissions {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(init) {
+    const { data } = await this.client.GET("/api/permissions", {
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Projects {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/projects", {
+      params: { path: { workspaceId: input.workspaceId }, query: { includeArchived: input.includeArchived } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/projects", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async get(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/projects/{projectId}", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/projects/{projectId}", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/projects/{projectId}", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async archive(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/projects/{projectId}/archive", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async restore(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/projects/{projectId}/restore", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listMembers(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/projects/{projectId}/members", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async addMember(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/projects/{projectId}/members", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async setMemberRole(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/projects/{projectId}/members/{projectMemberId}", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId, projectMemberId: input.projectMemberId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async removeMember(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/projects/{projectId}/members/{projectMemberId}", {
+      params: { path: { workspaceId: input.workspaceId, projectId: input.projectId, projectMemberId: input.projectMemberId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Roles {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/roles", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/roles", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/roles/{roleId}", {
+      params: { path: { workspaceId: input.workspaceId, roleId: input.roleId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/roles/{roleId}", {
+      params: { path: { workspaceId: input.workspaceId, roleId: input.roleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async duplicate(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/roles/{roleId}/duplicate", {
+      params: { path: { workspaceId: input.workspaceId, roleId: input.roleId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class SiteAnalyses {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async start(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/site-analyses", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async get(input, init) {
+    const { data } = await this.client.GET("/api/site-analyses/{analysisId}", {
+      params: { path: { analysisId: input.analysisId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async apply(input, init) {
+    const { data } = await this.client.POST("/api/site-analyses/{analysisId}/apply", {
+      params: { path: { analysisId: input.analysisId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Social {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async generate(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/social", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/social", {
+      params: { path: { articleId: input.articleId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Translations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async estimate(input, init) {
+    const { data } = await this.client.GET("/api/articles/{articleId}/translations/estimate", {
+      params: { path: { articleId: input.articleId }, query: { language: input.language } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/articles/{articleId}/translations", {
+      params: { path: { articleId: input.articleId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Usage {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async listTransactions(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/transactions", {
+      params: { path: { workspaceId: input.workspaceId }, query: { limit: input.limit } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async get(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/usage", {
+      params: { path: { workspaceId: input.workspaceId }, query: { from: input.from, to: input.to, projectId: input.projectId, userId: input.userId, type: input.type, provider: input.provider, limit: input.limit } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listPayments(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/payments", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listQuotas(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/quotas", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async setQuota(input, init) {
+    const { data } = await this.client.PUT("/api/workspaces/{workspaceId}/quotas", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Webhooks {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/webhooks", {
+      params: { path: { workspaceId: input.workspaceId }, query: { deliveryStatus: input.deliveryStatus } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/webhooks", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async delete(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/webhooks/{endpointId}", {
+      params: { path: { workspaceId: input.workspaceId, endpointId: input.endpointId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class Workspaces {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(init) {
+    const { data } = await this.client.GET("/api/workspaces", {
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async create(input, init) {
+    const { data } = await this.client.POST("/api/workspaces", {
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async get(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async update(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body ?? {},
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async listMembers(input, init) {
+    const { data } = await this.client.GET("/api/workspaces/{workspaceId}/members", {
+      params: { path: { workspaceId: input.workspaceId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async addMember(input, init) {
+    const { data } = await this.client.POST("/api/workspaces/{workspaceId}/members", {
+      params: { path: { workspaceId: input.workspaceId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async setMemberRoles(input, init) {
+    const { data } = await this.client.PATCH("/api/workspaces/{workspaceId}/members/{memberId}", {
+      params: { path: { workspaceId: input.workspaceId, memberId: input.memberId } },
+      body: input.body,
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+  async removeMember(input, init) {
+    const { data } = await this.client.DELETE("/api/workspaces/{workspaceId}/members/{memberId}", {
+      params: { path: { workspaceId: input.workspaceId, memberId: input.memberId } },
+      signal: init?.signal,
+      timeoutMs: init?.timeoutMs
+    });
+    return data;
+  }
+}
+
+class PrismDraftResources {
+  apiKeys;
+  articleGroups;
+  articles;
+  billing;
+  blog;
+  brandVoices;
+  briefs;
+  calendar;
+  categories;
+  contentTemplates;
+  dashboard;
+  generation;
+  ideas;
+  integrations;
+  invitations;
+  knowledge;
+  links;
+  permissions;
+  projects;
+  roles;
+  siteAnalyses;
+  social;
+  translations;
+  usage;
+  webhooks;
+  workspaces;
+  constructor(client) {
+    this.apiKeys = new ApiKeys(client);
+    this.articleGroups = new ArticleGroups(client);
+    this.articles = new Articles(client);
+    this.billing = new Billing(client);
+    this.blog = new Blog(client);
+    this.brandVoices = new BrandVoices(client);
+    this.briefs = new Briefs(client);
+    this.calendar = new Calendar(client);
+    this.categories = new Categories(client);
+    this.contentTemplates = new ContentTemplates(client);
+    this.dashboard = new Dashboard(client);
+    this.generation = new Generation(client);
+    this.ideas = new Ideas(client);
+    this.integrations = new Integrations(client);
+    this.invitations = new Invitations(client);
+    this.knowledge = new Knowledge(client);
+    this.links = new Links(client);
+    this.permissions = new Permissions(client);
+    this.projects = new Projects(client);
+    this.roles = new Roles(client);
+    this.siteAnalyses = new SiteAnalyses(client);
+    this.social = new Social(client);
+    this.translations = new Translations(client);
+    this.usage = new Usage(client);
+    this.webhooks = new Webhooks(client);
+    this.workspaces = new Workspaces(client);
+  }
+}
+
+// src/errors.ts
+class PrismDraftError extends Error {
+  status;
+  code;
+  details;
+  constructor(status, code, message, details) {
+    super(message);
+    this.name = "PrismDraftError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+}
+
+class PrismDraftTimeoutError extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`The request did not finish within ${timeoutMs} ms`);
+    this.name = "PrismDraftTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class WebhookSignatureError extends Error {
+  constructor(message = "The webhook signature is not valid") {
+    super(message);
+    this.name = "WebhookSignatureError";
+  }
+}
+
+class WebhookPayloadError extends WebhookSignatureError {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "WebhookPayloadError";
+    this.reason = reason;
+  }
+}
+
+class UnknownWebhookEventError extends Error {
+  event;
+  constructor(event) {
+    super(`Unknown webhook event "${event}"`);
+    this.name = "UnknownWebhookEventError";
+    this.event = event;
+  }
+}
+
+// src/middleware.ts
+var throwOnError = {
+  async onResponse({ response }) {
+    if (response.ok)
+      return;
+    const text = await response.clone().text();
+    let parsed;
+    try {
+      parsed = text.length > 0 ? JSON.parse(text) : undefined;
+    } catch {
+      parsed = undefined;
+    }
+    const body = parsed?.error;
+    if (typeof body?.code === "string" && typeof body.message === "string") {
+      throw new PrismDraftError(response.status, body.code, body.message, body.details);
+    }
+    throw new PrismDraftError(response.status, "INTERNAL_ERROR", response.statusText || `HTTP ${response.status}`);
+  }
+};
+var rejectUnsafePathParams = {
+  onRequest({ params }) {
+    for (const [name, value] of Object.entries(params.path ?? {})) {
+      const text = String(value);
+      if (text === "" || text === "." || text === "..") {
+        throw new TypeError(`Path parameter "${name}" must not be empty, "." or ".." (got ${JSON.stringify(text)})`);
+      }
+    }
+    return;
+  }
+};
+var rejectNonJsonBody = {
+  async onResponse({ response }) {
+    if (!response.ok)
+      return;
+    const text = await response.clone().text();
+    if (text.length === 0)
+      return;
+    try {
+      JSON.parse(text);
+    } catch {
+      throw new PrismDraftError(response.status, "INVALID_RESPONSE", "The API returned a non-JSON body");
+    }
+    return;
+  }
+};
+
+// src/retry.ts
+var RETRYABLE_STATUS = new Set([429, 502, 503, 504]);
+var DEFAULT_MAX_RETRY_DELAY_MS = 8000;
+var BASE_WAIT_MS = 250;
+var MAX_TIMER_MS = 2 ** 31 - 1;
+function assertDuration(name, value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new TypeError(`PrismDraft: ${name} must be a finite number above 0, got ${String(value)}`);
+  }
+}
+function anySignal(signals) {
+  if (typeof AbortSignal.any === "function")
+    return AbortSignal.any(signals);
+  const controller = new AbortController;
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+var defaultSleep = (ms, signal) => new Promise((resolve) => {
+  const timer = setTimeout(resolve, ms);
+  signal?.addEventListener("abort", () => clearTimeout(timer), { once: true });
+});
+function retryAfterMs(response) {
+  const raw = response.headers.get("retry-after")?.trim();
+  if (raw === undefined || raw === "")
+    return;
+  const ms = /^\d+(\.\d+)?$/.test(raw) ? Number(raw) * 1000 : Date.parse(raw) - Date.now();
+  return Number.isFinite(ms) && ms > 0 ? ms : undefined;
+}
+function wait(sleep, ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted)
+      return reject(signal.reason);
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    sleep(ms, signal).then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function releaseWhenSettled(response, release) {
+  if (response.body === null) {
+    release();
+    return response;
+  }
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          release();
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        release();
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      release();
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(body, response);
+}
+function retryingFetch(inner, options = {}) {
+  const maxRetries = options.maxRetries ?? 2;
+  const sleep = options.sleep ?? defaultSleep;
+  const maxDelay = options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+  assertDuration("maxRetryDelayMs", maxDelay);
+  if (options.timeoutMs !== undefined)
+    assertDuration("timeoutMs", options.timeoutMs);
+  return async (input) => {
+    const idempotent = input.method === "GET" || input.method === "HEAD";
+    const timeoutMs = input.timeoutMs ?? options.timeoutMs;
+    if (timeoutMs !== undefined)
+      assertDuration("timeoutMs", timeoutMs);
+    for (let attempt = 0;; attempt++) {
+      input.signal.throwIfAborted();
+      let request = idempotent ? input.clone() : input;
+      let timer;
+      let timeout;
+      if (timeoutMs !== undefined) {
+        const expiry = new AbortController;
+        timeout = expiry;
+        timer = setTimeout(() => expiry.abort(new PrismDraftTimeoutError(timeoutMs)), Math.min(timeoutMs, MAX_TIMER_MS));
+        timer.unref?.();
+        try {
+          request = new Request(request, { signal: anySignal([input.signal, expiry.signal]) });
+        } catch (error) {
+          clearTimeout(timer);
+          throw error;
+        }
+      }
+      const release = () => clearTimeout(timer);
+      const backoff = Math.min(BASE_WAIT_MS * 2 ** attempt, maxDelay);
+      let delay;
+      try {
+        const response = await inner(request);
+        if (!idempotent || !RETRYABLE_STATUS.has(response.status) || attempt >= maxRetries) {
+          return releaseWhenSettled(response, release);
+        }
+        const asked = retryAfterMs(response);
+        if (asked !== undefined && asked > maxDelay)
+          return releaseWhenSettled(response, release);
+        if (response.status === 429 && asked === undefined) {
+          return releaseWhenSettled(response, release);
+        }
+        delay = asked ?? backoff;
+      } catch (error) {
+        clearTimeout(timer);
+        if (input.signal.aborted)
+          throw input.signal.reason;
+        const failure = timeout?.signal.aborted ? timeout.signal.reason : error;
+        if (!idempotent || attempt >= maxRetries)
+          throw failure;
+        delay = backoff;
+      }
+      clearTimeout(timer);
+      await wait(sleep, delay, input.signal);
+    }
+  };
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.prism-draft.com";
+function isHttpUrl(value) {
+  try {
+    const { protocol } = new URL(value);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var RESERVED_INIT_KEYS = ["body", "method", "headers", "signal"];
+function withRequestInit(inner, requestInit) {
+  if (requestInit === undefined)
+    return inner;
+  const init = { ...requestInit };
+  for (const key of RESERVED_INIT_KEYS)
+    delete init[key];
+  return (input) => inner(input, init);
+}
+
+class PrismDraft extends PrismDraftResources {
+  raw;
+  constructor(options) {
+    if (typeof options.apiKey !== "string" || options.apiKey.trim() === "") {
+      throw new TypeError("PrismDraft: apiKey is empty (is the environment variable set?)");
+    }
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    if (!isHttpUrl(baseUrl)) {
+      throw new TypeError(`PrismDraft: baseUrl must be an absolute http(s) URL, got "${baseUrl}"`);
+    }
+    const raw = createOpenApiClient({
+      baseUrl,
+      headers: { authorization: `Bearer ${options.apiKey}` },
+      fetch: retryingFetch(withRequestInit(options.fetch ?? fetch, options.requestInit), {
+        maxRetries: options.maxRetries ?? 2,
+        timeoutMs: options.timeoutMs,
+        maxRetryDelayMs: options.maxRetryDelayMs
+      })
+    });
+    raw.use(rejectUnsafePathParams, throwOnError, rejectNonJsonBody);
+    super(raw);
+    this.raw = raw;
+  }
+}
+// src/webhook-events.ts
+var WEBHOOK_EVENTS = [
+  "article.created",
+  "article.generation.started",
+  "article.generation.completed",
+  "article.generation.failed",
+  "article.approved",
+  "article.rejected",
+  "article.published",
+  "article.updated",
+  "article.unpublished",
+  "image.generated",
+  "image.regenerated",
+  "credits.purchased",
+  "credits.granted",
+  "credits.consumed"
+];
+var ARTICLE_SNAPSHOT_KEYS = [
+  "articleId",
+  "workspaceId",
+  "projectId",
+  "slug",
+  "status",
+  "primaryLanguage",
+  "translationGroupId",
+  "title"
+];
+var WEBHOOK_EVENT_KEYS = {
+  "article.created": ["articleId", "projectId", "title"],
+  "article.generation.started": ["articleId", "jobId", "estimatedCredits"],
+  "article.generation.completed": ["articleId", "jobId", "consumedCredits"],
+  "article.generation.failed": ["articleId", "jobId", "error"],
+  "article.approved": ["articleId", "reviewId", "previousStatus"],
+  "article.rejected": ["articleId", "reviewId", "decision"],
+  "article.published": ARTICLE_SNAPSHOT_KEYS,
+  "article.updated": [...ARTICLE_SNAPSHOT_KEYS, "changed", "previousSlug"],
+  "article.unpublished": [...ARTICLE_SNAPSHOT_KEYS, "previousStatus", "reason"],
+  "image.generated": ["articleId", "assetId", "type"],
+  "image.regenerated": ["articleId", "assetId", "type"],
+  "credits.purchased": ["creditAmount", "stripeEventId"],
+  "credits.granted": ["creditAmount", "stripeEventId"],
+  "credits.consumed": ["articleId", "jobId", "credits"]
+};
+
+// src/webhooks.ts
+var WEBHOOK_SIGNATURE_HEADER = "x-prism-draft-signature";
+var DEFAULT_TOLERANCE_SECONDS = 300;
+var encoder = new TextEncoder;
+function hexToBytes(hex) {
+  if (hex.length === 0 || hex.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(hex))
+    return null;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let index = 0;index < bytes.length; index++) {
+    bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+}
+function parseSignature(header) {
+  const fields = new Map;
+  for (const part of header.split(",")) {
+    const at = part.indexOf("=");
+    if (at < 0)
+      continue;
+    const name = part.slice(0, at).trim();
+    if (fields.has(name))
+      return null;
+    fields.set(name, part.slice(at + 1).trim());
+  }
+  return fields;
+}
+async function verifyWebhookSignature(input) {
+  const tolerance = input.toleranceSeconds ?? DEFAULT_TOLERANCE_SECONDS;
+  if (typeof tolerance !== "number" || !Number.isFinite(tolerance) || tolerance < 0) {
+    throw new RangeError("toleranceSeconds must be a finite number of seconds, 0 or more");
+  }
+  const now = input.now ?? Math.floor(Date.now() / 1000);
+  if (input.secret.length === 0)
+    return false;
+  const fields = parseSignature(input.signature);
+  if (fields === null)
+    return false;
+  const timestamp = Number(fields.get("t"));
+  const provided = hexToBytes(fields.get("v1") ?? "");
+  if (!Number.isInteger(timestamp) || provided === null)
+    return false;
+  if (Math.abs(now - timestamp) > tolerance)
+    return false;
+  const body = typeof input.rawBody === "string" ? encoder.encode(input.rawBody) : input.rawBody;
+  const prefix = encoder.encode(`${timestamp}.`);
+  const message = new Uint8Array(prefix.length + body.length);
+  message.set(prefix, 0);
+  message.set(body, prefix.length);
+  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
+  return crypto.subtle.verify("HMAC", key, provided, message);
+}
+async function constructWebhookEvent(input) {
+  if (!await verifyWebhookSignature(input))
+    throw new WebhookSignatureError;
+  const text = typeof input.rawBody === "string" ? input.rawBody : new TextDecoder().decode(input.rawBody);
+  let envelope;
+  try {
+    envelope = JSON.parse(text);
+  } catch {
+    throw new WebhookPayloadError("not_json", "The webhook body is not JSON");
+  }
+  const { event, data } = envelope ?? {};
+  if (typeof event !== "string" || typeof data !== "object" || data === null) {
+    throw new WebhookPayloadError("not_envelope", "The webhook body is not an { event, data } envelope");
+  }
+  if (!WEBHOOK_EVENTS.includes(event)) {
+    throw new UnknownWebhookEventError(event);
+  }
+  return { event, data };
+}
+export {
+  ApiKeys,
+  ArticleGroups,
+  Articles,
+  Billing,
+  Blog,
+  BrandVoices,
+  Briefs,
+  Calendar,
+  Categories,
+  ContentTemplates,
+  DEFAULT_BASE_URL,
+  Dashboard,
+  Generation,
+  Ideas,
+  Integrations,
+  Invitations,
+  Knowledge,
+  Links,
+  Permissions,
+  PrismDraft,
+  PrismDraftError,
+  PrismDraftResources,
+  PrismDraftTimeoutError,
+  Projects,
+  Roles,
+  SiteAnalyses,
+  Social,
+  Translations,
+  UnknownWebhookEventError,
+  Usage,
+  WEBHOOK_EVENTS,
+  WEBHOOK_SIGNATURE_HEADER,
+  WebhookPayloadError,
+  WebhookSignatureError,
+  Webhooks,
+  Workspaces,
+  constructWebhookEvent,
+  retryingFetch,
+  throwOnError,
+  verifyWebhookSignature
+};