@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/chunk-EHUSD3O2.js

@@ -0,0 +1,377 @@
+import {
+  pointLedgerReferenceSchema
+} from "./chunk-W7YSMSGC.js";
+import {
+  authProviderSchema,
+  entitlementSchema,
+  identifier,
+  pageCursorSchema,
+  pickupAvailabilitySchema,
+  pickupSelectionSchema,
+  signInProviderOptionSchema,
+  skipEnrollmentSchema,
+  telegramSignInMethodsSchema,
+  walletSignInNetworksSchema
+} from "./chunk-ID3BZXFZ.js";
+
+// src/sign-in-providers.ts
+import * as z from "zod";
+var authProvidersSchema = /* @__PURE__ */ (() => z.object({
+  providers: z.array(
+    z.object({
+      provider: authProviderSchema,
+      configured: z.boolean()
+    })
+  ),
+  email: z.boolean(),
+  /** The wallet sign-in this project enabled. */
+  wallets: walletSignInNetworksSchema,
+  demo: z.boolean(),
+  /**
+   * Telegram's sign-in, which is not one of `providers` in SDK 1.x. Absent from Relay versions
+   * without Telegram. `login` is deprecated in favour of `signInProviders`; `miniApp` is not.
+   */
+  telegram: telegramSignInMethodsSchema.optional(),
+  /**
+   * Every sign-in provider the platform has, Telegram included, and whether Domino configured it:
+   * the open sibling of `providers`, which SDK 1.x keeps to `AuthProvider`. A newer Relay may list
+   * providers this SDK does not know. Absent from older Relay versions.
+   */
+  signInProviders: z.array(signInProviderOptionSchema).optional()
+}))();
+
+// src/creator-accounts.ts
+import * as z2 from "zod";
+var knownCreatorAccountProviders = ["youtube", "tiktok"];
+var creatorAccountProviderSchema = /* @__PURE__ */ (() => z2.custom(
+  (value) => typeof value === "string" && /^[a-z][a-z0-9-]{0,39}$/.test(value)
+))();
+var creatorAccountSchema = /* @__PURE__ */ (() => z2.object({
+  provider: creatorAccountProviderSchema,
+  configured: z2.boolean(),
+  status: z2.enum(["disconnected", "connected", "reconnect"]),
+  subject: z2.string().nullable(),
+  revision: z2.number().int().nonnegative(),
+  profile: z2.object({
+    name: z2.string().optional(),
+    username: z2.string().optional(),
+    imageUrl: z2.string().optional()
+  }).nullable()
+}))();
+var creatorAccountsSchema = /* @__PURE__ */ (() => z2.object({
+  accounts: z2.array(creatorAccountSchema)
+}))();
+
+// src/consent.ts
+import * as z3 from "zod";
+var consentWordingMaxLength = 2e3;
+var knownConsentChannels = ["email"];
+var openValue = /* @__PURE__ */ (() => z3.string().min(1).max(64))();
+var memberConsentSchema = /* @__PURE__ */ (() => z3.object({
+  member: identifier,
+  channel: openValue,
+  state: openValue,
+  at: z3.number().int().safe().nonnegative(),
+  wording: z3.string().nullable(),
+  source: openValue
+}))();
+var memberConsentListSchema = /* @__PURE__ */ (() => z3.array(memberConsentSchema))();
+var consentInputSchema = /* @__PURE__ */ (() => z3.object({
+  actionId: identifier,
+  channel: z3.custom(
+    (value) => typeof value === "string" && value.length <= 64
+  ),
+  granted: z3.boolean(),
+  wording: z3.string().optional()
+}).strict())();
+var memberConsentInputSchema = /* @__PURE__ */ (() => z3.object({
+  actionId: identifier,
+  member: identifier,
+  channel: z3.string().max(64),
+  granted: z3.boolean(),
+  wording: z3.string().optional()
+}).strict())();
+var memberConsentHistorySchema = /* @__PURE__ */ (() => z3.object({
+  items: z3.array(memberConsentSchema),
+  nextCursor: z3.string().nullable()
+}))();
+var memberConsentHistoryQuerySchema = /* @__PURE__ */ (() => z3.object({
+  cursor: z3.string().max(2e3).optional(),
+  limit: z3.coerce.number().int().min(1).max(100).optional()
+}).strict())();
+
+// src/collection.ts
+import * as z4 from "zod";
+var collectionCodeSchema = /* @__PURE__ */ (() => z4.string().regex(/^relay:collect:[a-f0-9]{64}$/))();
+var collectionPassSchema = /* @__PURE__ */ (() => z4.object({
+  code: collectionCodeSchema,
+  expiresAt: z4.number(),
+  entitlement: identifier
+}))();
+var collectionResolveSchema = /* @__PURE__ */ (() => z4.object({ code: collectionCodeSchema }).strict())();
+var collectionBeginSchema = /* @__PURE__ */ (() => collectionResolveSchema.extend({
+  actionId: identifier,
+  revision: z4.number().int().positive(),
+  selection: pickupSelectionSchema.optional()
+}))();
+var collectionPreviewSchema = /* @__PURE__ */ (() => z4.object({
+  entitlement: entitlementSchema,
+  inventory: pickupAvailabilitySchema,
+  expiresAt: z4.number()
+}))();
+
+// src/outcomes.ts
+import * as z5 from "zod";
+var timestamp = /* @__PURE__ */ (() => z5.number().int().safe().nonnegative())();
+var questEnrollmentInputSchema = /* @__PURE__ */ (() => z5.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier
+}))();
+var memberEnrollmentInputSchema = /* @__PURE__ */ (() => questEnrollmentInputSchema.extend({
+  member: identifier
+}))();
+var questEnrollmentSchema = /* @__PURE__ */ (() => z5.object({
+  /** Stable quest ID. */
+  quest: identifier,
+  member: identifier,
+  enrolledAt: timestamp
+}))();
+var questClaimInputSchema = /* @__PURE__ */ (() => z5.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier,
+  /** The outcome's tracker, as `QuestOutcome.tracker` names it. */
+  tracker: identifier,
+  record: z5.string().min(1).max(256),
+  observedAt: timestamp
+}))();
+var QuestOutcomeState = {
+  Admitted: "admitted",
+  Skipped: "skipped"
+};
+var questOutcomeSchema = /* @__PURE__ */ (() => z5.object({
+  /** Prerequisite transition identity; absent on older tracker responses. */
+  automatic: identifier.optional(),
+  /** Stable quest ID. */
+  quest: identifier,
+  /** Stable tracker ID of the record decided. */
+  tracker: identifier.nullable(),
+  /** The record's ID in its tracker. */
+  record: z5.string().nullable(),
+  /** Which observation of the record was decided. */
+  observedAt: timestamp.nullable(),
+  state: z5.enum(["admitted", "skipped"]),
+  /**
+   * Why it was skipped, one of `trackerSkipCodes` or a code a newer Relay sends; null when
+   * admitted. Show an unknown code by its `reason`.
+   */
+  code: z5.string().nullable(),
+  /** Why it was skipped, for people; null when admitted. */
+  reason: z5.string().nullable(),
+  /** Which window refused admission when `code` is `outside-window`. */
+  window: z5.enum(["tracker", "quest"]).optional(),
+  /** Which enrollment the member lacks when `code` is `not-enrolled`: the quest's or its campaign's. */
+  enrollment: skipEnrollmentSchema,
+  /** The admitted attempt. */
+  attempt: identifier.nullable(),
+  /** The member can claim it with `relay.quests.claim()`. */
+  claimable: z5.boolean(),
+  createdAt: timestamp,
+  updatedAt: timestamp
+}))();
+var questOutcomeQuerySchema = /* @__PURE__ */ (() => z5.strictObject({
+  /** Quest key or ID. */
+  quest: identifier.optional(),
+  state: z5.enum(["admitted", "skipped"]).optional(),
+  /** Only skips with this code, such as `historical`. */
+  code: z5.string().min(1).max(100).optional(),
+  cursor: pageCursorSchema.optional()
+}))();
+var questOutcomePageSchema = /* @__PURE__ */ (() => z5.object({
+  items: z5.array(questOutcomeSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+
+// src/participant-rewards.ts
+import * as z6 from "zod";
+var participantEntitlementsSchema = /* @__PURE__ */ (() => z6.object({
+  items: z6.array(entitlementSchema)
+}))();
+var base = /* @__PURE__ */ (() => ({
+  id: z6.string(),
+  status: z6.string(),
+  at: z6.number().nullable(),
+  quest: z6.string().nullable(),
+  completion: z6.string().nullable()
+}))();
+var known = /* @__PURE__ */ (() => z6.discriminatedUnion("kind", [
+  z6.object({
+    ...base,
+    kind: z6.literal("points"),
+    ledger: pointLedgerReferenceSchema,
+    amount: z6.number(),
+    reversed: z6.number()
+  }).catchall(z6.json()),
+  z6.object({
+    ...base,
+    kind: z6.literal("tier"),
+    entitlement: entitlementSchema
+  }).catchall(z6.json().transform((value) => value)),
+  z6.object({
+    ...base,
+    kind: z6.literal("integration"),
+    provider: z6.string(),
+    action: z6.string(),
+    roleId: z6.string().optional(),
+    deliveredAt: z6.number().nullable(),
+    revokedAt: z6.number().nullable(),
+    reconciliation: z6.object({ status: z6.string(), ownership: z6.string(), at: z6.number() }).catchall(z6.json()).nullable()
+  }).catchall(z6.json().optional())
+]))();
+var participantDeliverySchema = /* @__PURE__ */ (() => z6.union([
+  known,
+  z6.object({
+    ...base,
+    kind: z6.string().refine((kind) => !["points", "tier", "integration"].includes(kind))
+  }).catchall(z6.json()).transform(({ kind, ...item }) => ({
+    ...item,
+    kind: "unknown",
+    reportedKind: kind
+  }))
+]))();
+var participantDeliveriesSchema = /* @__PURE__ */ (() => z6.object({
+  items: z6.array(participantDeliverySchema)
+}))();
+
+// src/reward-deliveries.ts
+import * as z7 from "zod";
+var RewardDeliveryAction = {
+  /** Delivers a quest's Discord role reward. */
+  GrantRole: "grant-role",
+  /**
+   * Posts a quest's announcement in a Telegram chat or Discord channel. Its `provider` is
+   * `telegram` or `discord`, and its `roleId` is empty.
+   */
+  PostMessage: "post-message"
+};
+var rewardDeliveryActionSchema = /* @__PURE__ */ (() => z7.string().min(1).max(64))();
+var roleReconciliationSchema = /* @__PURE__ */ (() => z7.object({
+  status: z7.enum(["pending", "granted", "removed", "preserved", "failed"]),
+  ownership: z7.enum(["unclaimed", "relay", "external"]),
+  at: z7.number(),
+  reason: z7.string().nullable()
+}))();
+var knownRewardDeliverySchema = /* @__PURE__ */ (() => z7.object({
+  id: z7.string(),
+  quest: z7.string(),
+  completion: z7.string(),
+  member: z7.string(),
+  provider: z7.literal("discord"),
+  /** `RewardDeliveryAction`, such as `grant-role`. */
+  action: rewardDeliveryActionSchema,
+  roleId: z7.string(),
+  /**
+   * `failed` is terminal: Discord rejected the grant permanently (unknown role,
+   * member left the server, missing permissions) or retries ran out after about
+   * a day. An operator can retry it once the cause is fixed, unless revokedAt is set.
+   * Revoke stops pending grants; a late success records deliveredAt but leaves status failed.
+   */
+  status: z7.enum(["pending", "delivered", "failed"]),
+  /** Provider attempts in the current round; an operator retry starts a new round at zero. */
+  attempts: z7.number().int(),
+  /** While pending with a `lastError`, when the next attempt is scheduled. */
+  nextAt: z7.number(),
+  lastError: z7.string().nullable(),
+  createdAt: z7.number(),
+  deliveredAt: z7.number().nullable(),
+  /** First dispatch attempt, retained across retries. Legacy rows use creation time when dispatch timing is unknown. */
+  dispatchedAt: z7.number().nullable().optional(),
+  /** Completion revocation stops retries, including deliveries that had already failed. */
+  revokedAt: z7.number().nullable().optional(),
+  /** Current reconciliation of the pinned Discord membership; original delivery and revoke history stay intact. */
+  reconciliation: roleReconciliationSchema.nullable().optional()
+}))();
+var futureRewardDeliverySchema = /* @__PURE__ */ (() => knownRewardDeliverySchema.extend({
+  provider: z7.string(),
+  status: z7.string(),
+  roleId: z7.string().optional(),
+  reconciliation: z7.object({
+    status: z7.string(),
+    ownership: z7.string(),
+    at: z7.number(),
+    reason: z7.string().nullable()
+  }).catchall(z7.json()).nullable().optional()
+}).catchall(z7.json().optional()).refine(
+  (delivery) => delivery.provider !== "discord" || !["pending", "delivered", "failed"].includes(delivery.status) || delivery.reconciliation && (!["pending", "granted", "removed", "preserved", "failed"].includes(
+    delivery.reconciliation.status
+  ) || !["unclaimed", "relay", "external"].includes(
+    delivery.reconciliation.ownership
+  ))
+))();
+var rewardDeliverySchema = /* @__PURE__ */ (() => z7.union([
+  knownRewardDeliverySchema.catchall(z7.json().optional()),
+  futureRewardDeliverySchema
+]))();
+var rewardDeliveriesSchema = /* @__PURE__ */ (() => z7.object({
+  deliveries: z7.array(rewardDeliverySchema),
+  items: z7.array(rewardDeliverySchema).optional(),
+  nextCursor: pageCursorSchema.nullable().default(null)
+}))();
+var rewardDeliveryQuerySchema = /* @__PURE__ */ (() => z7.strictObject({
+  cursor: pageCursorSchema.optional(),
+  limit: z7.coerce.number().int().min(1).max(500).optional()
+}))();
+var discordRoleRewardSchema = /* @__PURE__ */ (() => z7.object({
+  roleId: z7.string(),
+  quests: z7.array(z7.string()),
+  /** Delivery records of this role by `RewardDelivery.status`. */
+  deliveries: z7.object({
+    pending: z7.number().int(),
+    delivered: z7.number().int(),
+    failed: z7.number().int()
+  })
+}))();
+var discordRoleRewardsSchema = /* @__PURE__ */ (() => z7.object({
+  roles: z7.array(discordRoleRewardSchema)
+}))();
+
+export {
+  authProvidersSchema,
+  knownCreatorAccountProviders,
+  creatorAccountProviderSchema,
+  creatorAccountSchema,
+  creatorAccountsSchema,
+  consentWordingMaxLength,
+  knownConsentChannels,
+  memberConsentSchema,
+  memberConsentListSchema,
+  consentInputSchema,
+  memberConsentInputSchema,
+  memberConsentHistorySchema,
+  memberConsentHistoryQuerySchema,
+  collectionCodeSchema,
+  collectionPassSchema,
+  collectionResolveSchema,
+  collectionBeginSchema,
+  collectionPreviewSchema,
+  questEnrollmentInputSchema,
+  memberEnrollmentInputSchema,
+  questEnrollmentSchema,
+  questClaimInputSchema,
+  QuestOutcomeState,
+  questOutcomeSchema,
+  questOutcomeQuerySchema,
+  questOutcomePageSchema,
+  participantEntitlementsSchema,
+  participantDeliverySchema,
+  participantDeliveriesSchema,
+  RewardDeliveryAction,
+  roleReconciliationSchema,
+  knownRewardDeliverySchema,
+  rewardDeliverySchema,
+  rewardDeliveriesSchema,
+  rewardDeliveryQuerySchema,
+  discordRoleRewardSchema,
+  discordRoleRewardsSchema
+};

package/dist/chunk-FO2LCZTL.js

@@ -0,0 +1,19 @@
+// src/definition-error.ts
+function issueText(issues) {
+  return issues.map(
+    (issue) => issue.path.length ? issue.path.map(String).join(".") + ": " + issue.message : issue.message
+  ).join("; ");
+}
+function parseDefinition(kind, schema, input) {
+  const parsed = schema.safeParse(input);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const key = typeof input === "object" && input !== null && "key" in input && typeof input.key === "string" ? ` "${input.key}"` : "";
+  parsed.error.message = `${kind}${key} is invalid: ${issueText(parsed.error.issues)}`;
+  throw parsed.error;
+}
+
+export {
+  parseDefinition
+};