@oxyhq/crowdsource-contracts 0.1.0

package/dist/index.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Public entry point for `@oxyhq/crowdsource-contracts`.
+ *
+ * The contracts every CrowdSource surface agrees on: the backend, the reviewer
+ * and console clients, the published SDKs, and third-party integrators. One
+ * entry point because the package publishes one `exports` path — this is the
+ * package boundary, not a convenience barrel over an internal tree.
+ *
+ * Two version numbers live here and mean different things. `/v1` is the route
+ * prefix and is not this package's business. `CASE_ENVELOPE_SCHEMA_VERSION`
+ * travels inside the payload and is validated separately (§10.11). Additive
+ * changes bump neither.
+ *
+ * Where strictness lands, and why, since it is the one thing a reader will want
+ * to look up:
+ *
+ *   * **Inbound from a tenant or a reviewer — strict.** The Case Envelope tree,
+ *     the review submission, the recusal, the policy set, the resource schema
+ *     registration. A dropped field here is context a jury never sees or an
+ *     input nobody reviewed, and §10.11 makes the exception explicitly for
+ *     fields "the schema forbids for safety".
+ *   * **Outbound to a tenant — loose.** Decisions, webhook envelopes and event
+ *     payloads pass unknown fields through, so a newer CrowdSource never breaks
+ *     an older client and a receiver that persists `event.data` keeps all of it.
+ *   * **Internal, to Oxy Trust — strict.** The reputation event carries no
+ *     resource ids and no free text on purpose; an unrecognised field is how
+ *     content reaches a reputation ledger. The `.v1` in the event type is what
+ *     handles evolution there.
+ *
+ * Open bags (`metadata`, custom payloads, registered JSON Schemas) are the
+ * deliberate exception in both directions: open by definition, but flat or
+ * depth-bounded, scalar-typed, key-restricted and free of prototype-bearing
+ * names.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./primitives"), exports);
+__exportStar(require("./taxonomy"), exports);
+__exportStar(require("./policies"), exports);
+__exportStar(require("./resources"), exports);
+__exportStar(require("./case-envelope"), exports);
+__exportStar(require("./reviews"), exports);
+__exportStar(require("./decisions"), exports);
+__exportStar(require("./webhooks"), exports);
+__exportStar(require("./reputation-events"), exports);
+__exportStar(require("./json-schema"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;;;;;;;;;;;;;;;;AAEH,+CAA6B;AAC7B,6CAA2B;AAC3B,6CAA2B;AAC3B,8CAA4B;AAC5B,kDAAgC;AAChC,4CAA0B;AAC1B,8CAA4B;AAC5B,6CAA2B;AAC3B,sDAAoC;AACpC,gDAA8B"}

package/dist/json-schema.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The same contracts as JSON Schema, for integrators who are not on TypeScript.
+ *
+ * §15.2 asks for "Zod and exportable JSON Schema". Conversion is deliberately
+ * lazy — a function, not a frozen constant — so importing the package to
+ * validate one report does not pay for thirteen schema conversions.
+ *
+ * **What JSON Schema does NOT carry.** Zod refinements have no JSON Schema
+ * equivalent and are dropped silently by the conversion. Everything structural
+ * survives — types, enums, patterns, bounds, required keys, `additionalProperties`
+ * — and every cross-field and cross-reference rule does not:
+ *
+ *   * §5.5 reference resolution (relations, `primaryResourceId`, allegation
+ *     resource ids, author and seller refs, conversation members, avatars)
+ *   * the `oxy_user` binding-proof requirement
+ *   * exactly-one-of `uploadId`/`url`, media type agreement, coarse coordinates,
+ *     price-with-currency
+ *   * `agreement = winningVotes / decisiveVotes` and the vote count nesting
+ *   * revision 1 supersedes nothing / later revisions must
+ *   * `externalReportId` matching between request and envelope
+ *
+ * So a payload that passes the JSON Schema is well-FORMED, not accepted. The
+ * server validates with Zod, and that is the authority. This is stated here
+ * because an integrator who assumes otherwise will build against a contract
+ * that is looser than the one they will meet in production, and will discover
+ * the difference as a 422.
+ */
+import { z } from 'zod';
+/** A JSON Schema document, as produced by the conversion. */
+export type JsonSchemaDocument = z.core.JSONSchema.BaseSchema;
+export declare const CONTRACT_JSON_SCHEMA_NAMES: readonly ["case-envelope", "create-report-request", "create-report-response", "resource", "relation", "resource-schema-registration", "policy-set-version", "review-submission", "recusal-submission", "decision", "webhook-event-envelope", "known-webhook-event", "reputation-event"];
+export type ContractJsonSchemaName = (typeof CONTRACT_JSON_SCHEMA_NAMES)[number];
+/**
+ * The Zod schema behind each published name.
+ *
+ * Typed as an exhaustive `Record` so adding a name without a schema — or a
+ * schema without a name — is a compile error rather than a runtime hole in the
+ * exported contract set.
+ */
+export declare const CONTRACT_SCHEMAS: Record<ContractJsonSchemaName, z.ZodType>;
+/** The JSON Schema for one published contract. */
+export declare function crowdSourceJsonSchema(name: ContractJsonSchemaName): JsonSchemaDocument;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;AAE9D,eAAO,MAAM,0BAA0B,yRAc7B,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,sBAAsB,EAAE,CAAC,CAAC,OAAO,CActE,CAAC;AAKF,kDAAkD;AAClD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,sBAAsB,GAAG,kBAAkB,CAEtF"}

package/dist/json-schema.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * The same contracts as JSON Schema, for integrators who are not on TypeScript.
+ *
+ * §15.2 asks for "Zod and exportable JSON Schema". Conversion is deliberately
+ * lazy — a function, not a frozen constant — so importing the package to
+ * validate one report does not pay for thirteen schema conversions.
+ *
+ * **What JSON Schema does NOT carry.** Zod refinements have no JSON Schema
+ * equivalent and are dropped silently by the conversion. Everything structural
+ * survives — types, enums, patterns, bounds, required keys, `additionalProperties`
+ * — and every cross-field and cross-reference rule does not:
+ *
+ *   * §5.5 reference resolution (relations, `primaryResourceId`, allegation
+ *     resource ids, author and seller refs, conversation members, avatars)
+ *   * the `oxy_user` binding-proof requirement
+ *   * exactly-one-of `uploadId`/`url`, media type agreement, coarse coordinates,
+ *     price-with-currency
+ *   * `agreement = winningVotes / decisiveVotes` and the vote count nesting
+ *   * revision 1 supersedes nothing / later revisions must
+ *   * `externalReportId` matching between request and envelope
+ *
+ * So a payload that passes the JSON Schema is well-FORMED, not accepted. The
+ * server validates with Zod, and that is the authority. This is stated here
+ * because an integrator who assumes otherwise will build against a contract
+ * that is looser than the one they will meet in production, and will discover
+ * the difference as a 422.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACT_SCHEMAS = exports.CONTRACT_JSON_SCHEMA_NAMES = void 0;
+exports.crowdSourceJsonSchema = crowdSourceJsonSchema;
+const zod_1 = require("zod");
+const case_envelope_1 = require("./case-envelope");
+const decisions_1 = require("./decisions");
+const policies_1 = require("./policies");
+const reputation_events_1 = require("./reputation-events");
+const resources_1 = require("./resources");
+const reviews_1 = require("./reviews");
+const webhooks_1 = require("./webhooks");
+exports.CONTRACT_JSON_SCHEMA_NAMES = [
+    'case-envelope',
+    'create-report-request',
+    'create-report-response',
+    'resource',
+    'relation',
+    'resource-schema-registration',
+    'policy-set-version',
+    'review-submission',
+    'recusal-submission',
+    'decision',
+    'webhook-event-envelope',
+    'known-webhook-event',
+    'reputation-event',
+];
+/**
+ * The Zod schema behind each published name.
+ *
+ * Typed as an exhaustive `Record` so adding a name without a schema — or a
+ * schema without a name — is a compile error rather than a runtime hole in the
+ * exported contract set.
+ */
+exports.CONTRACT_SCHEMAS = {
+    'case-envelope': case_envelope_1.CaseEnvelopeSchema,
+    'create-report-request': case_envelope_1.CreateReportRequestSchema,
+    'create-report-response': case_envelope_1.CreateReportResponseSchema,
+    resource: resources_1.ResourceSchema,
+    relation: resources_1.RelationSchema,
+    'resource-schema-registration': resources_1.ResourceSchemaRegistrationSchema,
+    'policy-set-version': policies_1.PolicySetVersionSchema,
+    'review-submission': reviews_1.ReviewSubmissionSchema,
+    'recusal-submission': reviews_1.RecusalSubmissionSchema,
+    decision: decisions_1.DecisionSchema,
+    'webhook-event-envelope': webhooks_1.WebhookEventEnvelopeSchema,
+    'known-webhook-event': webhooks_1.KnownWebhookEventSchema,
+    'reputation-event': reputation_events_1.ReputationEventSchema,
+};
+/** JSON Schema draft 2020-12, so `$defs` and `unevaluatedProperties` mean what integrators expect. */
+const JSON_SCHEMA_TARGET = 'draft-2020-12';
+/** The JSON Schema for one published contract. */
+function crowdSourceJsonSchema(name) {
+    return zod_1.z.toJSONSchema(exports.CONTRACT_SCHEMAS[name], { target: JSON_SCHEMA_TARGET });
+}
+//# sourceMappingURL=json-schema.js.map

package/dist/json-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.js","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AA4DH,sDAEC;AA5DD,6BAAwB;AAExB,mDAA4G;AAC5G,2CAA6C;AAC7C,yCAAoD;AACpD,2DAA4D;AAC5D,2CAA+F;AAC/F,uCAA4E;AAC5E,yCAAiF;AAKpE,QAAA,0BAA0B,GAAG;IACxC,eAAe;IACf,uBAAuB;IACvB,wBAAwB;IACxB,UAAU;IACV,UAAU;IACV,8BAA8B;IAC9B,oBAAoB;IACpB,mBAAmB;IACnB,oBAAoB;IACpB,UAAU;IACV,wBAAwB;IACxB,qBAAqB;IACrB,kBAAkB;CACV,CAAC;AAIX;;;;;;GAMG;AACU,QAAA,gBAAgB,GAA8C;IACzE,eAAe,EAAE,kCAAkB;IACnC,uBAAuB,EAAE,yCAAyB;IAClD,wBAAwB,EAAE,0CAA0B;IACpD,QAAQ,EAAE,0BAAc;IACxB,QAAQ,EAAE,0BAAc;IACxB,8BAA8B,EAAE,4CAAgC;IAChE,oBAAoB,EAAE,iCAAsB;IAC5C,mBAAmB,EAAE,gCAAsB;IAC3C,oBAAoB,EAAE,iCAAuB;IAC7C,QAAQ,EAAE,0BAAc;IACxB,wBAAwB,EAAE,qCAA0B;IACpD,qBAAqB,EAAE,kCAAuB;IAC9C,kBAAkB,EAAE,yCAAqB;CAC1C,CAAC;AAEF,sGAAsG;AACtG,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAE3C,kDAAkD;AAClD,SAAgB,qBAAqB,CAAC,IAA4B;IAChE,OAAO,OAAC,CAAC,YAAY,CAAC,wBAAgB,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;AAChF,CAAC"}

package/dist/policies.d.ts

@@ -0,0 +1,286 @@
+/**
+ * The application-policy layer (§6.1 layer 2) and policy versioning (§6.4).
+ *
+ * The taxonomy says what the material contains; a policy set says whether that
+ * violates THIS application's rules. The two are versioned independently and
+ * every decision records both (plus the Oxy conduct policy version), because
+ * §6.4 forbids a policy update from silently changing what a past decision
+ * meant.
+ *
+ * The security boundary of this module is §6.4's last line: "rules must be
+ * expressed as data, not as arbitrary code supplied by the tenant". A rule here
+ * therefore has an id, a title, the taxonomy codes it responds to, a default
+ * severity and recommended actions — and no expression, predicate, script,
+ * template or callback field of any kind. That absence is the control. It is
+ * enforced by `.strict()`: a policy set carrying an unrecognised key is
+ * rejected outright rather than accepted with the key quietly dropped, because
+ * "dropped" and "never evaluated" look identical right up until something
+ * decides to evaluate it.
+ */
+import { z } from 'zod';
+/** A namespaced policy set id, e.g. `mention.community`. */
+export declare const PolicySetIdSchema: z.ZodString;
+/** A rule id within a policy set, e.g. `mention.harassment.2`. */
+export declare const PolicyRuleIdSchema: z.ZodString;
+/**
+ * An immutable policy version token, e.g. `2026.07`, `mention.2026.07`,
+ * `oxy.2026.1`.
+ *
+ * Deliberately not semver: the plan's own tokens are calendar-shaped and
+ * tenant-prefixed, and a policy version is an opaque label pointing at a frozen
+ * document — nothing compares two of them for ordering.
+ */
+export declare const PolicyVersionSchema: z.ZodString;
+/**
+ * The version of the Oxy Conduct Policy every decision is stamped with (§6.4).
+ *
+ * §6.1 assigns the third layer — "should this conduct affect global Oxy trust?"
+ * — to the Oxy Conduct Policy, evaluated by the Reputation Bridge. That bridge
+ * does not exist yet, and this constant is deliberately NOT a promise that it
+ * does. What it is: the label a decision published today records, so that when
+ * the bridge arrives it can tell which conduct policy a historical decision was
+ * decided under and refuse to re-interpret it under a newer one. §6.4's "a
+ * policy update never silently rewrites historical decisions" is unenforceable
+ * without a version on every decision from the first one.
+ *
+ * The value is Appendix B's. It is pinned here, in the package both the
+ * decision DTO and the reputation event import, so the two cannot drift into
+ * describing the same decision under two different conduct policies.
+ */
+export declare const OXY_CONDUCT_POLICY_VERSION = "oxy.2026.1";
+/**
+ * The policy an envelope asks to be evaluated under (§5.1 `policy`).
+ *
+ * `locale` selects the language the policy text is shown to the reviewer in
+ * (Appendix A), and is not the language of the reported material — that is
+ * `resource.language`.
+ */
+export declare const CasePolicyRefSchema: z.ZodObject<{
+    policySetId: z.ZodString;
+    version: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CasePolicyRef = z.infer<typeof CasePolicyRefSchema>;
+/**
+ * The three policy versions a decision is decided under (§6.4).
+ *
+ * Field names follow Appendix B (`taxonomy`), which is the reference Decision.
+ * §6.4's prose calls the same field `universalTaxonomyVersion` and §11.6's
+ * internal event calls it `universal`; see `ReputationPolicyVersionsSchema` for
+ * why both spellings survive.
+ */
+export declare const DecisionPolicyVersionsSchema: z.ZodObject<{
+    taxonomy: z.ZodString;
+    application: z.ZodString;
+    oxyConduct: z.ZodString;
+}, z.core.$loose>;
+export type DecisionPolicyVersions = z.infer<typeof DecisionPolicyVersionsSchema>;
+/**
+ * The same three versions as carried by the internal reputation event (§11.6).
+ *
+ * §11.6 spells the first key `universal` where Appendix B spells it `taxonomy`.
+ * Both are reference payloads in the approved plan and both are load-bearing
+ * for a different consumer, so each surface keeps the spelling its own
+ * reference document uses rather than one of the two documents being quietly
+ * rewritten here. Unifying them is a one-line change and worth doing when the
+ * event contract is agreed with OxyHQServices — it is called out in the package
+ * README as the single naming inconsistency the contract preserves on purpose.
+ */
+export declare const ReputationPolicyVersionsSchema: z.ZodObject<{
+    universal: z.ZodString;
+    application: z.ZodString;
+    oxyConduct: z.ZodString;
+}, z.core.$strict>;
+export type ReputationPolicyVersions = z.infer<typeof ReputationPolicyVersionsSchema>;
+/** §6.4: a draft may be edited, a published version may not. */
+export declare const POLICY_SET_STATUSES: readonly ["draft", "published"];
+export declare const PolicySetStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+}>;
+export type PolicySetStatus = z.infer<typeof PolicySetStatusSchema>;
+/**
+ * One rule inside a policy version — data, never code.
+ *
+ * `taxonomyCodes` is what binds layer 2 back to layer 1: the rule declares
+ * which universal findings it responds to, so a jury classifies once (§9.2 step
+ * one) and any number of applications evaluate that same classification against
+ * their own rules (§6.2).
+ */
+export declare const PolicyRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    taxonomyCodes: z.ZodArray<z.ZodEnum<{
+        "integrity.spam": "integrity.spam";
+        "integrity.scam": "integrity.scam";
+        "integrity.fraud": "integrity.fraud";
+        "integrity.impersonation": "integrity.impersonation";
+        "integrity.coordinated_manipulation": "integrity.coordinated_manipulation";
+        "harassment.insult": "harassment.insult";
+        "harassment.targeted_abuse": "harassment.targeted_abuse";
+        "harassment.sexual_harassment": "harassment.sexual_harassment";
+        "harassment.doxxing": "harassment.doxxing";
+        "harassment.credible_threat": "harassment.credible_threat";
+        "hate.dehumanization": "hate.dehumanization";
+        "hate.slur": "hate.slur";
+        "hate.incitement": "hate.incitement";
+        "hate.protected_targeting": "hate.protected_targeting";
+        "violence.graphic": "violence.graphic";
+        "violence.threat": "violence.threat";
+        "violence.instruction": "violence.instruction";
+        "violence.celebration": "violence.celebration";
+        "sexual_content.nudity": "sexual_content.nudity";
+        "sexual_content.explicit_activity": "sexual_content.explicit_activity";
+        "sexual_content.non_consensual": "sexual_content.non_consensual";
+        "sexual_content.exploitation": "sexual_content.exploitation";
+        "child_safety.sexualization": "child_safety.sexualization";
+        "child_safety.grooming": "child_safety.grooming";
+        "child_safety.exploitation": "child_safety.exploitation";
+        "self_harm.promotion": "self_harm.promotion";
+        "self_harm.instruction": "self_harm.instruction";
+        "self_harm.imminent_risk": "self_harm.imminent_risk";
+        "privacy.personal_information": "privacy.personal_information";
+        "privacy.intimate_media": "privacy.intimate_media";
+        "privacy.location_exposure": "privacy.location_exposure";
+        "commerce.prohibited_item": "commerce.prohibited_item";
+        "commerce.counterfeit": "commerce.counterfeit";
+        "commerce.misleading_listing": "commerce.misleading_listing";
+        "commerce.unsafe_product": "commerce.unsafe_product";
+        "platform_abuse.ban_evasion": "platform_abuse.ban_evasion";
+        "platform_abuse.report_abuse": "platform_abuse.report_abuse";
+        "platform_abuse.automation_abuse": "platform_abuse.automation_abuse";
+        "other.policy_specific": "other.policy_specific";
+        "other.unclassifiable": "other.unclassifiable";
+    }>>;
+    defaultSeverity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>>;
+    recommendedActions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        remove_or_restrict: "remove_or_restrict";
+        allow_with_label: "allow_with_label";
+        remove: "remove";
+        hide: "hide";
+        label: "label";
+        age_gate: "age_gate";
+        reduce_distribution: "reduce_distribution";
+        freeze_transaction: "freeze_transaction";
+        suspend_user: "suspend_user";
+        request_changes: "request_changes";
+        allow: "allow";
+        restore: "restore";
+        no_action: "no_action";
+        request_more_context: "request_more_context";
+        hold: "hold";
+        local_manual_review: "local_manual_review";
+        keep_restricted_temporarily: "keep_restricted_temporarily";
+        escalate: "escalate";
+        no_global_effect: "no_global_effect";
+        specialist_queue: "specialist_queue";
+        legal_queue: "legal_queue";
+        safety_queue: "safety_queue";
+    }>>>;
+}, z.core.$strict>;
+export type PolicyRule = z.infer<typeof PolicyRuleSchema>;
+/**
+ * A policy set at one version (§6.4).
+ *
+ * The `status`/`publishedAt` pairing is the immutability rule expressed where a
+ * schema can express it: a published version must record when it was published,
+ * and a draft must not claim to have been. Actual immutability — never
+ * rewriting a published version's rules — is a storage rule the registry
+ * enforces; no parse can see a second write.
+ */
+export declare const PolicySetVersionSchema: z.ZodObject<{
+    policySetId: z.ZodString;
+    version: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+    }>;
+    title: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+    publishedAt: z.ZodOptional<z.ZodISODateTime>;
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        taxonomyCodes: z.ZodArray<z.ZodEnum<{
+            "integrity.spam": "integrity.spam";
+            "integrity.scam": "integrity.scam";
+            "integrity.fraud": "integrity.fraud";
+            "integrity.impersonation": "integrity.impersonation";
+            "integrity.coordinated_manipulation": "integrity.coordinated_manipulation";
+            "harassment.insult": "harassment.insult";
+            "harassment.targeted_abuse": "harassment.targeted_abuse";
+            "harassment.sexual_harassment": "harassment.sexual_harassment";
+            "harassment.doxxing": "harassment.doxxing";
+            "harassment.credible_threat": "harassment.credible_threat";
+            "hate.dehumanization": "hate.dehumanization";
+            "hate.slur": "hate.slur";
+            "hate.incitement": "hate.incitement";
+            "hate.protected_targeting": "hate.protected_targeting";
+            "violence.graphic": "violence.graphic";
+            "violence.threat": "violence.threat";
+            "violence.instruction": "violence.instruction";
+            "violence.celebration": "violence.celebration";
+            "sexual_content.nudity": "sexual_content.nudity";
+            "sexual_content.explicit_activity": "sexual_content.explicit_activity";
+            "sexual_content.non_consensual": "sexual_content.non_consensual";
+            "sexual_content.exploitation": "sexual_content.exploitation";
+            "child_safety.sexualization": "child_safety.sexualization";
+            "child_safety.grooming": "child_safety.grooming";
+            "child_safety.exploitation": "child_safety.exploitation";
+            "self_harm.promotion": "self_harm.promotion";
+            "self_harm.instruction": "self_harm.instruction";
+            "self_harm.imminent_risk": "self_harm.imminent_risk";
+            "privacy.personal_information": "privacy.personal_information";
+            "privacy.intimate_media": "privacy.intimate_media";
+            "privacy.location_exposure": "privacy.location_exposure";
+            "commerce.prohibited_item": "commerce.prohibited_item";
+            "commerce.counterfeit": "commerce.counterfeit";
+            "commerce.misleading_listing": "commerce.misleading_listing";
+            "commerce.unsafe_product": "commerce.unsafe_product";
+            "platform_abuse.ban_evasion": "platform_abuse.ban_evasion";
+            "platform_abuse.report_abuse": "platform_abuse.report_abuse";
+            "platform_abuse.automation_abuse": "platform_abuse.automation_abuse";
+            "other.policy_specific": "other.policy_specific";
+            "other.unclassifiable": "other.unclassifiable";
+        }>>;
+        defaultSeverity: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        recommendedActions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            remove_or_restrict: "remove_or_restrict";
+            allow_with_label: "allow_with_label";
+            remove: "remove";
+            hide: "hide";
+            label: "label";
+            age_gate: "age_gate";
+            reduce_distribution: "reduce_distribution";
+            freeze_transaction: "freeze_transaction";
+            suspend_user: "suspend_user";
+            request_changes: "request_changes";
+            allow: "allow";
+            restore: "restore";
+            no_action: "no_action";
+            request_more_context: "request_more_context";
+            hold: "hold";
+            local_manual_review: "local_manual_review";
+            keep_restricted_temporarily: "keep_restricted_temporarily";
+            escalate: "escalate";
+            no_global_effect: "no_global_effect";
+            specialist_queue: "specialist_queue";
+            legal_queue: "legal_queue";
+            safety_queue: "safety_queue";
+        }>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PolicySetVersion = z.infer<typeof PolicySetVersionSchema>;
+//# sourceMappingURL=policies.d.ts.map

package/dist/policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../src/policies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,4DAA4D;AAC5D,eAAO,MAAM,iBAAiB,aAO3B,CAAC;AAEJ,kEAAkE;AAClE,eAAO,MAAM,kBAAkB,aAO5B,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,aAO7B,CAAC;AAEJ;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,eAAe,CAAC;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;kBAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B;;;;iBAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;;;;kBAIzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,iCAAkC,CAAC;AACnE,eAAO,MAAM,qBAAqB;;;EAA8B,CAAC;AACjE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAU3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqC/B,CAAC;AACL,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}