@qaecy/cue-sdk 0.0.54 → 0.0.55

package/lib/profile.d.ts

@@ -1,7 +1,8 @@
 import { UserInfo } from 'firebase/auth';
-import { APIKeyDoc, APIKeyInfo, FileTypeBreakdownDto, OrgConsumptionReportDto, OrgCreditsDto, OrgMember, OrganizationData, ProfileSSOAccount, TrafficReportDto, UsageReportDto } from './models';
+import { APIKeyDoc, APIKeyInfo, FileTypeBreakdownDto, OrgConsumptionReportDto, OrgCredits, OrgCreditsDto, OrgMember, OrganizationData, ProfileSSOAccount, TrafficReportDto, UsageReportDto } from './models';
 import { CueAuth } from './auth';
 import { ReadonlySignal } from './signal';
+import { OrgSignUpPlan } from './signup';
 export declare class CueProfile {
     private readonly _auth;
     private readonly _gatewayUrl;
@@ -11,10 +12,12 @@ export declare class CueProfile {
      * by `getOrgCredits()` and by the sync layer after every `previewSync`/
      * `sync`/`computeCredits` call, so consumers that bind to this signal see
      * balance changes (e.g. after an upload) without polling or manually
-     * re-fetching. Angular consumers bridge via
+     * re-fetching. The value carries the `orgId` it belongs to: fetches for
+     * different orgs can resolve out of order, so check it against the org on
+     * screen before showing the balance. Angular consumers bridge via
      * `effect(() => sig.set(cue.profile.orgCredits.get()))` + `.subscribe(...)`.
      */
-    readonly orgCredits: ReadonlySignal<OrgCreditsDto | undefined>;
+    readonly orgCredits: ReadonlySignal<OrgCredits | undefined>;
     constructor(_auth: CueAuth, _gatewayUrl: string);
     private _url;
     private _fetch;
@@ -46,6 +49,39 @@ export declare class CueProfile {
     listOrganizations(): Promise<(Pick<OrganizationData, 'id' | 'name'> & {
         isAdmin: boolean;
     })[]>;
+    /**
+     * Creates an organisation with the current user as its admin — for a user
+     * who belongs to none. It claims the user's email domain when that email is
+     * verified, not a free-mail provider and not claimed already; otherwise it is
+     * created without a domain. Throws `CueRequestError` with `code`
+     * 'alreadyInOrganisation' when the user already belongs to one.
+     */
+    createOwnOrganization(orgName: string, plan: OrgSignUpPlan): Promise<{
+        orgId: string;
+        orgName: string;
+        domains: string[];
+        checkoutUrl?: string;
+    }>;
+    /**
+     * Asks to join the organisation owning `domain` (e.g. `qaecy.com`); its
+     * admins get an email. Resolves the same whether or not any organisation
+     * owns the domain, so it can't be used to find out. Throws `CueRequestError`
+     * with `code` 'emailNotVerified' | 'invalidDomain'.
+     */
+    requestToJoinOrganization(domain: string): Promise<void>;
+    /**
+     * Joins the organisation owning the current user's email domain — only once
+     * that email is verified, which is why sign-up itself never joins one. Call
+     * it when a signed-in user has no organisation; `joined` is false when the
+     * email is unverified or no organisation owns the domain.
+     */
+    joinOrganizationByEmailDomain(): Promise<{
+        joined: boolean;
+        orgId?: string;
+        orgName?: string;
+    }>;
+    /** POSTs JSON and surfaces the backend's error `code`, for calls whose failures a UI maps. */
+    private _fetchCoded;
     /** Returns all members of the given organisation. Caller must be an org admin or superadmin. */
     getOrgMembers(orgId: string): Promise<OrgMember[]>;
     /** Returns just the given organisation's admins. Caller must be a member (or admin/superadmin). */

package/lib/semantic-template.d.ts

@@ -32,6 +32,37 @@ export interface EntityRelationshipInput extends EntityCategoryInput {
     sources: string[];
     targets: string[];
 }
+/** A declared canonical's new value. Changing it changes the canonical's IRI, and everything pointing at it moves too. */
+export interface RenameCanonicalInput {
+    categoryKey: string;
+    canonicalKey: string;
+    newValue: string;
+    /** The schema revision the caller read; a stale one is refused. */
+    revision: number;
+    /** When the new value is already a canonical of the category. Defaults to `merge`. */
+    onCollision?: 'merge' | 'refuse';
+    /** Record the old value as a resolved form of the new canonical. Defaults to `false`. */
+    keepOldAsAlias?: boolean;
+    /** Report what would change and write nothing. */
+    dryRun?: boolean;
+}
+export interface RenameCanonicalResult {
+    oldIri: string;
+    newIri: string;
+    collision: boolean;
+    /** Set when the collision is with another canonical declared in the schema. */
+    collidesWithKey?: string;
+    dryRun: boolean;
+    quads: number;
+    mentions: number;
+    files: number;
+    graphs: number;
+    dataSources: number;
+    /** The saved schema's revision; absent on a dry run. */
+    revision?: number;
+    /** Follow-up steps that failed after the graph moved — running the same rename again finishes them. */
+    warnings: string[];
+}
 /**
  * One project the caller could take an existing schema from — what
  * `listSchemaSources` lists.
@@ -53,7 +84,7 @@ export interface SchemaSource {
     relations: number;
 }
 /**
- * Client for writers-commands' semantic-template CRUD endpoints — persists a
+ * Client for writers-cue-bff's semantic-template CRUD endpoints — persists a
  * project's custom extraction/classification schema (content categories,
  * entity categories, entity relationships) and reloads the project's
  * `databases-cue` schema graph after every mutation.
@@ -124,6 +155,11 @@ export declare class CueSemanticTemplate {
     reloadSchema(projectId: string): Promise<MutationResult>;
     private _get;
     private _send;
+    /**
+     * Changes a declared canonical's value. Needs the syncer or admin role. Run it with `dryRun`
+     * first to see what would move and whether the new value collides.
+     */
+    renameCanonical(projectId: string, input: RenameCanonicalInput): Promise<RenameCanonicalResult>;
     private _post;
     private _delete;
     private _errorMessage;

package/lib/signup.d.ts

@@ -39,17 +39,16 @@ export declare class CueSignUp {
     private readonly _gatewayUrl;
     constructor(_gatewayUrl: string);
     /**
-     * Register a new user by name and email.
-     * The backend validates that the email domain belongs to an existing organisation,
-     * creates the Firebase Auth account, assigns org membership, and — when no
-     * `password` is given — dispatches a "set your password" email to the
-     * address provided. `termsVersion`, when given, is recorded as accepted
-     * immediately so the user isn't asked again on their next sign-in.
-     * Returns the new user's UID and the organisation name on success.
+     * Register a new user by name and email. The account starts without an
+     * organisation and the answer is the same whatever the email's domain; the
+     * user joins the organisation owning that domain once the email is verified
+     * (see `CueProfile.joinOrganizationByEmailDomain`). When no `password` is
+     * given, a "set your password" email is sent. `termsVersion`, when given, is
+     * recorded as accepted immediately so the user isn't asked again on their
+     * next sign-in.
      */
     signUp(name: string, email: string, password?: string, termsVersion?: string): Promise<{
         uid: string;
-        orgName: string;
     }>;
     /**
      * Self-service sign-up that creates a new organisation together with its

package/lib/usage-stats.d.ts

@@ -3,7 +3,7 @@ import { CueAuth } from './auth';
  * Records portal view-opens for usage reporting (per-user, per-view, per-project) —
  * fed into the same GCS-aggregate pipeline as gateway traffic tracking, but written
  * by the frontend directly instead of Kong's `http-log` plugin. See
- * apps/writers/commands/src/app/admin/usage/usage-ingest.service.ts.
+ * apps/writers/cue-bff/src/app/admin/usage/usage-ingest.service.ts.
  */
 export declare class CueUsageStats {
     private readonly _auth;