@oxy.so/contracts 4.17.0 → 4.22.0

package/dist/esm/serviceToken.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/** Omitted means the existing grant; an explicit set only narrows that authority. */
+export const serviceTokenScopesSchema = z
+    .array(z.string().trim().min(1).max(128))
+    .min(1)
+    .max(100)
+    .refine((scopes) => new Set(scopes).size === scopes.length, 'Requested scopes must be unique')
+    .transform((scopes) => [...scopes].sort());
+export const serviceTokenOptionsSchema = z
+    .object({ scopes: serviceTokenScopesSchema.optional() })
+    .strict();

package/dist/types/accountAccess.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Wire contract for `GET /internal/accounts/:accountId/access/:userId`: Oxy
+ * answers a trusted first-party service's question "may this person act FOR
+ * that account, and with what?" with no session of that person in the request.
+ *
+ * It exists for the account Oxy never lets anybody act AS: a `channel`
+ * ({@link isDelegatedActAsEligibleKind} refuses it). An app publishes to a
+ * channel with ITS OWN credential, on behalf of a member Oxy vouches for here,
+ * so nobody holds a bearer that speaks as the channel. A long-running import
+ * (Oxy Move) has only a service token and `X-Oxy-User-Id`, which the
+ * user-facing `GET /accounts/:id/members` refuses; this is its answer.
+ *
+ * Needs a service token whose application is platform-trusted AND holds the
+ * privileged {@link ACCOUNTS_MEMBERSHIP_READ_SCOPE}. The answer is always 200:
+ * `access` is `null` for no active membership, an archived account, an unknown
+ * account and an unclaimed directory account alike. Callers must treat every
+ * other status as a refusal (fail closed), and must not cache the answer longer
+ * than the action it authorizes.
+ *
+ * Platform-agnostic — zod only.
+ */
+import { z } from 'zod';
+/**
+ * The scope the endpoint requires.
+ *
+ * Privileged (staff-granted). Channel membership is sensitive because a channel
+ * is anonymous: its members are the people behind a voice that is published
+ * without their names, and "is this person a member of that channel" is
+ * exactly the fact the channel exists to withhold.
+ */
+export declare const ACCOUNTS_MEMBERSHIP_READ_SCOPE: "accounts:membership:read";
+/**
+ * Where the access comes from.
+ *
+ * - `self` — the person IS the account (a personal account asked about itself).
+ * - `direct` — an active membership row on the account.
+ * - `inherited` — an active, cascading membership on an ancestor account.
+ */
+export declare const ACCOUNT_ACCESS_SOURCES: readonly ["self", "direct", "inherited"];
+export type AccountAccessSource = (typeof ACCOUNT_ACCESS_SOURCES)[number];
+export declare const accountAccessSourceSchema: z.ZodEnum<["self", "direct", "inherited"]>;
+/**
+ * One person's EFFECTIVE access over one account.
+ *
+ * `role` and `permissions` are strings rather than closed enums on purpose: the
+ * role and permission vocabularies are the API's, they grow, and a consumer
+ * pinned to an older contracts release must keep reading new ones. Gate on
+ * `permissions` (the role's baseline adjusted by per-member grants and
+ * revokes), never on `role`.
+ */
+export declare const accountAccessGrantSchema: z.ZodObject<{
+    role: z.ZodString;
+    permissions: z.ZodArray<z.ZodString, "many">;
+    /** Only an active membership grants access, so this is the one value. */
+    status: z.ZodLiteral<"active">;
+    source: z.ZodEnum<["self", "direct", "inherited"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "active";
+    role: string;
+    permissions: string[];
+    source: "self" | "direct" | "inherited";
+}, {
+    status: "active";
+    role: string;
+    permissions: string[];
+    source: "self" | "direct" | "inherited";
+}>;
+export type AccountAccessGrant = z.infer<typeof accountAccessGrantSchema>;
+export declare const accountAccessVerdictSchema: z.ZodEffects<z.ZodObject<{
+    accountId: z.ZodString;
+    /** `null` when no such account exists. */
+    kind: z.ZodNullable<z.ZodEnum<["personal", "organization", "project", "bot", "channel"]>>;
+    /** `null` means: this person may not act for this account. */
+    access: z.ZodNullable<z.ZodObject<{
+        role: z.ZodString;
+        permissions: z.ZodArray<z.ZodString, "many">;
+        /** Only an active membership grants access, so this is the one value. */
+        status: z.ZodLiteral<"active">;
+        source: z.ZodEnum<["self", "direct", "inherited"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active";
+        role: string;
+        permissions: string[];
+        source: "self" | "direct" | "inherited";
+    }, {
+        status: "active";
+        role: string;
+        permissions: string[];
+        source: "self" | "direct" | "inherited";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "organization" | "personal" | "project" | "bot" | "channel" | null;
+    accountId: string;
+    access: {
+        status: "active";
+        role: string;
+        permissions: string[];
+        source: "self" | "direct" | "inherited";
+    } | null;
+}, {
+    kind: "organization" | "personal" | "project" | "bot" | "channel" | null;
+    accountId: string;
+    access: {
+        status: "active";
+        role: string;
+        permissions: string[];
+        source: "self" | "direct" | "inherited";
+    } | null;
+}>, {
+    kind: "organization" | "personal" | "project" | "bot" | "channel" | null;
+    accountId: string;
+    access: {
+        status: "active";
+        role: string;
+        permissions: string[];
+        source: "self" | "direct" | "inherited";
+    } | null;
+}, {
+    kind: "organization" | "personal" | "project" | "bot" | "channel" | null;
+    accountId: string;
+    access: {
+        status: "active";
+        role: string;
+        permissions: string[];
+        source: "self" | "direct" | "inherited";
+    } | null;
+}>;
+export type AccountAccessVerdict = z.infer<typeof accountAccessVerdictSchema>;

package/dist/types/accountEmail.d.ts

@@ -24,11 +24,11 @@ export declare const emailVerificationStartRequestSchema: z.ZodObject<{
     purpose: z.ZodLiteral<"signup">;
     email: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    purpose: "signup";
     email: string;
-}, {
     purpose: "signup";
+}, {
     email: string;
+    purpose: "signup";
 }>;
 export type EmailVerificationStartRequest = z.infer<typeof emailVerificationStartRequestSchema>;
 export interface EmailVerificationStartResponse {