@aventurevc/api-schemas 0.7.283

package/dist/github/repo.js

@@ -0,0 +1,46 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+const GithubRepoSchemaDefinition = z.object({
+    createdAt: z.iso.datetime({ offset: true }).nullish(),
+    description: z.string().nullish(),
+    forkCount: z.int(),
+    /** GitHub's stable numeric repository id; sync upsert key per owner */
+    githubId: z.number().int(),
+    /** Project homepage URL declared on the repository */
+    homepageUrl: z.string().nullish(),
+    id: z.number().int(),
+    /** True when the repository is archived on GitHub */
+    isArchived: z.boolean(),
+    /** True when the repository is a fork of another repository */
+    isFork: z.boolean(),
+    /** Primary language reported by GitHub */
+    language: z.string().nullish(),
+    /** SPDX license id reported by GitHub */
+    license: z.string().nullish(),
+    /** Repository name (slug segment after the login) */
+    name: z.string(),
+    /** GitHub account login (org or user) the repository belongs to */
+    ownerLogin: z.string(),
+    /** GitHub created_at of the repository */
+    repoCreatedAt: z.iso.datetime({ offset: true }).nullish(),
+    /** GitHub pushed_at of the repository at last sync */
+    repoPushedAt: z.iso.datetime({ offset: true }).nullish(),
+    stargazerCount: z.int(),
+    /** Repository topics reported by GitHub */
+    topic: z.array(z.string()),
+    updatedAt: z.iso.datetime({ offset: true }).nullish(),
+    /** Canonical https GitHub repository page URL */
+    url: z.string(),
+});
+/**
+ * GitHub repository synced for an entity or person from their current github URL links. githubId is GitHub's stable numeric repository id; rows are replaced per owner on each sync, so counts and timestamps reflect the last sync.
+ *
+ * @openapiSchema GithubRepo
+ * @endpoint GET /v1/entities/{entityId}/repositories
+ * @endpoint GET /v1/people/{personId}/repositories
+ * @usedBySchema PageGithubRepoSchema
+ * @contractShape github.repo
+ * @contractRole canonical
+ */
+export const GithubRepoSchema = GithubRepoSchemaDefinition;
+//# sourceMappingURL=repo.js.map

package/dist/help/citation.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/v4";
+declare const HelpCitationSchemaDefinition: z.ZodObject<{
+    excerpt: z.ZodString;
+    sourceId: z.ZodString;
+    sourceType: z.ZodEnum<{
+        COMPLETION_GATE: "COMPLETION_GATE";
+        OPERATION: "OPERATION";
+        PROMPT: "PROMPT";
+        SKILL: "SKILL";
+    }>;
+    sourceVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type HelpCitationDefinition = z.infer<typeof HelpCitationSchemaDefinition>;
+/**
+ * A single corpus document the help answer is grounded in.
+ *
+ * @openapiSchema HelpCitation
+ * @endpoint POST /v1/agents/help
+ * @usedBySchema AgentHelpSchema
+ * @contractShape help.citation
+ * @contractRole canonical
+ */
+export declare const HelpCitationSchema: z.ZodType<HelpCitationDefinition>;
+export type HelpCitation = z.infer<typeof HelpCitationSchema>;
+export {};
+//# sourceMappingURL=citation.d.ts.map

package/dist/help/citation.js

@@ -0,0 +1,24 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+import { HelpSourceTypeSchema } from "./source-type.js";
+const HelpCitationSchemaDefinition = z.object({
+    /** Verbatim excerpt from the cited document supporting the answer. */
+    excerpt: z.string(),
+    /** Stable id within the source type: an operationId, a skill/prompt name, or a completion gate id. */
+    sourceId: z.string(),
+    /** Which part of the platform corpus this citation comes from. */
+    sourceType: HelpSourceTypeSchema,
+    /** Immutable version of the cited document when one exists (skill/prompt content version); null for catalog-derived sources. */
+    sourceVersion: z.string().nullish(),
+});
+/**
+ * A single corpus document the help answer is grounded in.
+ *
+ * @openapiSchema HelpCitation
+ * @endpoint POST /v1/agents/help
+ * @usedBySchema AgentHelpSchema
+ * @contractShape help.citation
+ * @contractRole canonical
+ */
+export const HelpCitationSchema = HelpCitationSchemaDefinition;
+//# sourceMappingURL=citation.js.map

package/dist/help/scope.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+/**
+ * Operation scope a help answer may recommend: read-only, write, or all.
+ *
+ * @openapiSchema HelpScope
+ * @endpoint POST /v1/agents/help
+ * @usedBySchema AgentHelpQuestionSchema
+ * @contractShape help.scope
+ * @contractRole canonical
+ */
+export declare const HelpScopeSchema: z.ZodEnum<{
+    ALL: "ALL";
+    READ: "READ";
+    WRITE: "WRITE";
+}>;
+export type HelpScope = z.infer<typeof HelpScopeSchema>;
+//# sourceMappingURL=scope.d.ts.map

package/dist/help/scope.js

@@ -0,0 +1,13 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+/**
+ * Operation scope a help answer may recommend: read-only, write, or all.
+ *
+ * @openapiSchema HelpScope
+ * @endpoint POST /v1/agents/help
+ * @usedBySchema AgentHelpQuestionSchema
+ * @contractShape help.scope
+ * @contractRole canonical
+ */
+export const HelpScopeSchema = z.enum(["READ", "WRITE", "ALL"]);
+//# sourceMappingURL=scope.js.map

package/dist/help/source-type.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod/v4";
+/**
+ * Corpus partition a help citation is drawn from.
+ *
+ * @openapiSchema HelpSourceType
+ * @endpoint POST /v1/agents/help
+ * @usedBySchema HelpCitationSchema
+ * @contractShape help.source-type
+ * @contractRole canonical
+ */
+export declare const HelpSourceTypeSchema: z.ZodEnum<{
+    COMPLETION_GATE: "COMPLETION_GATE";
+    OPERATION: "OPERATION";
+    PROMPT: "PROMPT";
+    SKILL: "SKILL";
+}>;
+export type HelpSourceType = z.infer<typeof HelpSourceTypeSchema>;
+//# sourceMappingURL=source-type.d.ts.map

package/dist/help/source-type.js

@@ -0,0 +1,13 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+/**
+ * Corpus partition a help citation is drawn from.
+ *
+ * @openapiSchema HelpSourceType
+ * @endpoint POST /v1/agents/help
+ * @usedBySchema HelpCitationSchema
+ * @contractShape help.source-type
+ * @contractRole canonical
+ */
+export const HelpSourceTypeSchema = z.enum(["OPERATION", "SKILL", "PROMPT", "COMPLETION_GATE"]);
+//# sourceMappingURL=source-type.js.map

package/dist/http/json-value.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * @usedByEndpoint none:external-root
+ * @shared primitive:single reusable JSON value helper; not direct because valid OpenAPI unconstrained value positions require a generated recursive value schema
+ * @contractShape http.json-value
+ * @contractRole canonical
+ * @ownerModule http/json-value.ts
+ */
+export declare const JsonValueSchema: z.ZodType<JsonValue>;
+//# sourceMappingURL=json-value.d.ts.map

package/dist/http/json-value.js

@@ -0,0 +1,18 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+/**
+ * @usedByEndpoint none:external-root
+ * @shared primitive:single reusable JSON value helper; not direct because valid OpenAPI unconstrained value positions require a generated recursive value schema
+ * @contractShape http.json-value
+ * @contractRole canonical
+ * @ownerModule http/json-value.ts
+ */
+export const JsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema),
+]));
+//# sourceMappingURL=json-value.js.map

package/dist/http/problem-detail.d.ts

@@ -0,0 +1,254 @@
+import { z } from "zod/v4";
+declare const ProblemDetailSchemaDefinition: z.ZodObject<{
+    circuitBreaker: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    code: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        GEOCODE_PROVIDER_ERROR: "GEOCODE_PROVIDER_ERROR";
+        INFERENCE_PROFILES_MISSING: "INFERENCE_PROFILES_MISSING";
+        INFERENCE_PROFILE_API_KEY_MISSING: "INFERENCE_PROFILE_API_KEY_MISSING";
+        INFERENCE_PROVIDER_ERROR: "INFERENCE_PROVIDER_ERROR";
+        INFERENCE_PROVIDER_INVALID_JSON: "INFERENCE_PROVIDER_INVALID_JSON";
+        INFERENCE_PROVIDER_RESPONSE_EMPTY: "INFERENCE_PROVIDER_RESPONSE_EMPTY";
+        JOBRUNR_DISABLED: "JOBRUNR_DISABLED";
+        JOBRUNR_STORAGE_UNAVAILABLE: "JOBRUNR_STORAGE_UNAVAILABLE";
+        frontend_cache_epoch_mode_not_targeted: "frontend_cache_epoch_mode_not_targeted";
+        github_fetch_failed: "github_fetch_failed";
+        image_blocklist_match: "image_blocklist_match";
+        image_brand_mismatch: "image_brand_mismatch";
+        image_monochrome: "image_monochrome";
+        image_monogram: "image_monogram";
+        image_processing_error: "image_processing_error";
+        image_too_small: "image_too_small";
+        image_unreadable: "image_unreadable";
+        image_wrong_aspect: "image_wrong_aspect";
+        news_rss_article_fetch_failed: "news_rss_article_fetch_failed";
+        news_rss_feed_fetch_failed: "news_rss_feed_fetch_failed";
+        news_similarity_embedding_unavailable: "news_similarity_embedding_unavailable";
+        not_authorized: "not_authorized";
+        origin_detail_capacity: "origin_detail_capacity";
+        origin_detail_shutdown: "origin_detail_shutdown";
+        r2_delete_failed: "r2_delete_failed";
+        r2_fetch_failed: "r2_fetch_failed";
+        r2_upload_failed: "r2_upload_failed";
+        rateLimited: "rateLimited";
+        rbac_lookup_unavailable: "rbac_lookup_unavailable";
+        search_provider_error: "search_provider_error";
+        search_provider_not_configured: "search_provider_not_configured";
+        sec_edgar_fetch_failed: "sec_edgar_fetch_failed";
+        sentry_api_error: "sentry_api_error";
+        source_document_body_unavailable: "source_document_body_unavailable";
+        source_document_capture_limit_exceeded: "source_document_capture_limit_exceeded";
+        suspectedShellStrip: "suspectedShellStrip";
+        swagger_headers_unconfigured: "swagger_headers_unconfigured";
+        url_surface_misclassification: "url_surface_misclassification";
+        web_crawl_fetch_failed: "web_crawl_fetch_failed";
+    }>>>;
+    conflictingRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        deletedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        id: z.ZodString;
+        isHidden: z.ZodBoolean;
+        nameBrand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        resourceType: z.ZodEnum<{
+            blog: "blog";
+            content: "content";
+            entity: "entity";
+            news: "news";
+            person: "person";
+        }>;
+        showOnSitemap: z.ZodBoolean;
+        slug: z.ZodString;
+    }, z.core.$strip>>>;
+    detail: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodType<{
+        existingJoin: {
+            owner: {
+                entityId?: string | null | undefined;
+                personId?: string | null | undefined;
+            };
+            urlId: number;
+        }[];
+        fragmentIgnored: boolean;
+        guidance: string;
+        normalizedUrl?: string | null | undefined;
+        requestedOwner: {
+            entityId?: string | null | undefined;
+            personId?: string | null | undefined;
+        };
+        url: string;
+        urlType: string;
+    }, unknown, z.core.$ZodTypeInternals<{
+        existingJoin: {
+            owner: {
+                entityId?: string | null | undefined;
+                personId?: string | null | undefined;
+            };
+            urlId: number;
+        }[];
+        fragmentIgnored: boolean;
+        guidance: string;
+        normalizedUrl?: string | null | undefined;
+        requestedOwner: {
+            entityId?: string | null | undefined;
+            personId?: string | null | undefined;
+        };
+        url: string;
+        urlType: string;
+    }, unknown>>, z.ZodType<{
+        candidateEntityId: string[];
+        candidatePersonId: string[];
+        hint: string;
+        normalizedUrl?: string | null | undefined;
+        url: string;
+        urlType?: string | null | undefined;
+    }, unknown, z.core.$ZodTypeInternals<{
+        candidateEntityId: string[];
+        candidatePersonId: string[];
+        hint: string;
+        normalizedUrl?: string | null | undefined;
+        url: string;
+        urlType?: string | null | undefined;
+    }, unknown>>, z.ZodType<{
+        candidate?: {
+            externalId?: string | null | undefined;
+            id: string;
+            name?: string | null | undefined;
+            operatingStatus?: string | null | undefined;
+            publicPath?: string | null | undefined;
+            reason: string[];
+            score: number;
+            slug?: string | null | undefined;
+            typeRecord?: "Business Line" | "Company" | "Fund" | "Government" | "Investment Firm" | "Nonprofit" | "Organization" | "Product" | "Service" | null | undefined;
+        }[] | null | undefined;
+        newsCandidate?: {
+            externalId?: string | null | undefined;
+            id: number;
+            reason: string[];
+            score: number;
+            slug?: string | null | undefined;
+        }[] | null | undefined;
+        overridePath?: string | null | undefined;
+        threshold: number;
+    }, unknown, z.core.$ZodTypeInternals<{
+        candidate?: {
+            externalId?: string | null | undefined;
+            id: string;
+            name?: string | null | undefined;
+            operatingStatus?: string | null | undefined;
+            publicPath?: string | null | undefined;
+            reason: string[];
+            score: number;
+            slug?: string | null | undefined;
+            typeRecord?: "Business Line" | "Company" | "Fund" | "Government" | "Investment Firm" | "Nonprofit" | "Organization" | "Product" | "Service" | null | undefined;
+        }[] | null | undefined;
+        newsCandidate?: {
+            externalId?: string | null | undefined;
+            id: number;
+            reason: string[];
+            score: number;
+            slug?: string | null | undefined;
+        }[] | null | undefined;
+        overridePath?: string | null | undefined;
+        threshold: number;
+    }, unknown>>, z.ZodType<{
+        availableOverrides: ("ATTACH_INACTIVE" | "REACTIVATE")[];
+        slug: string;
+        tagId: number;
+    }, unknown, z.core.$ZodTypeInternals<{
+        availableOverrides: ("ATTACH_INACTIVE" | "REACTIVATE")[];
+        slug: string;
+        tagId: number;
+    }, unknown>>, z.ZodType<{
+        conflictingArticleId: number;
+        conflictingArticleSlug: string;
+        conflictingArticleTitle: string;
+    }, unknown, z.core.$ZodTypeInternals<{
+        conflictingArticleId: number;
+        conflictingArticleSlug: string;
+        conflictingArticleTitle: string;
+    }, unknown>>]>>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    existingRedirect: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        newUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        oldUrl: z.ZodString;
+        targetCurrentSlug: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        targetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        targetResourceType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            blog: "blog";
+            content: "content";
+            entity: "entity";
+            news: "news";
+            person: "person";
+        }>>>;
+    }, z.core.$strip>>>;
+    feId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hammingDistance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    hint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    instance: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    limitType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        BILLING_ALLOWANCE: "BILLING_ALLOWANCE";
+        CLERK_PUBLIC_ADMISSION: "CLERK_PUBLIC_ADMISSION";
+        CLERK_SCRIPT_LOAD: "CLERK_SCRIPT_LOAD";
+        FORM: "FORM";
+        GLOBAL: "GLOBAL";
+        INFERENCE_PROVIDER: "INFERENCE_PROVIDER";
+        IP: "IP";
+        NATURAL_SEARCH: "NATURAL_SEARCH";
+        ORIGIN_DETAIL: "ORIGIN_DETAIL";
+        RESILIENCE4J: "RESILIENCE4J";
+        SUBNET: "SUBNET";
+        UNKNOWN: "UNKNOWN";
+        WEB_SEARCH: "WEB_SEARCH";
+    }>>>;
+    matchedBlocklistKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    mediaType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    moderationReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parseError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./json-value.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./json-value.ts").JsonValue, unknown>>>>;
+    remaining: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    requiredRole: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    resetAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    resolution: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        acceptedValue: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        action: z.ZodEnum<{
+            authenticate: "authenticate";
+            removeParameter: "removeParameter";
+            reviewCandidates: "reviewCandidates";
+            setField: "setField";
+            setParameter: "setParameter";
+            useEndpoint: "useEndpoint";
+        }>;
+        endpoint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fieldPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        parameter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    retryAfterSeconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    spanId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodInt>;
+    suggestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    suggestions: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    suspectedFragment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodOptional<z.ZodString>;
+    unknownParameters: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    used: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    validParameters: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    value: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    windowSeconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type ProblemDetailDefinition = z.infer<typeof ProblemDetailSchemaDefinition>;
+/**
+ * RFC 9457 problem response with aVenture extensions.
+ *
+ * @openapiSchema ProblemDetail
+ * @standardProblemResponse
+ * @contractShape http.problem-detail
+ * @contractRole canonical
+ */
+export declare const ProblemDetailSchema: z.ZodType<ProblemDetailDefinition>;
+export type ProblemDetail = z.infer<typeof ProblemDetailSchema>;
+export {};
+//# sourceMappingURL=problem-detail.d.ts.map

package/dist/http/problem-detail.js

@@ -0,0 +1,117 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+import { DomainConflictDetailsSchema } from "../domain/conflict-details.js";
+import { JsonValueSchema } from "./json-value.js";
+import { ProblemResolutionSchema } from "../problem/resolution.js";
+import { CurrentSlugOwnerSchema } from "../redirect/current-slug-owner.js";
+import { RedirectSlugPathSchema } from "../redirect/redirect-slug-path.js";
+const ProblemDetailSchemaDefinition = z.object({
+    circuitBreaker: z.string().nullish(),
+    /** Machine-readable secondary code on ProblemDetail.code. Agents should branch on this value when the HTTP status alone does not identify the recovery path. Code groups include auth/session, rate limiting, job infrastructure, RBAC, external providers, image processing, R2 storage, search, and inference. Many codes indicate infra/admin-only conditions where the correct agent action is to surface the error and stop, not retry. */
+    code: z
+        .enum([
+        "not_authorized",
+        "rateLimited",
+        "origin_detail_capacity",
+        "origin_detail_shutdown",
+        "suspectedShellStrip",
+        "url_surface_misclassification",
+        "JOBRUNR_DISABLED",
+        "JOBRUNR_STORAGE_UNAVAILABLE",
+        "rbac_lookup_unavailable",
+        "GEOCODE_PROVIDER_ERROR",
+        "sentry_api_error",
+        "swagger_headers_unconfigured",
+        "frontend_cache_epoch_mode_not_targeted",
+        "image_blocklist_match",
+        "image_monochrome",
+        "image_too_small",
+        "image_wrong_aspect",
+        "image_monogram",
+        "image_unreadable",
+        "image_processing_error",
+        "image_brand_mismatch",
+        "web_crawl_fetch_failed",
+        "news_rss_feed_fetch_failed",
+        "news_rss_article_fetch_failed",
+        "r2_fetch_failed",
+        "r2_delete_failed",
+        "r2_upload_failed",
+        "source_document_body_unavailable",
+        "source_document_capture_limit_exceeded",
+        "news_similarity_embedding_unavailable",
+        "search_provider_not_configured",
+        "search_provider_error",
+        "sec_edgar_fetch_failed",
+        "github_fetch_failed",
+        "INFERENCE_PROVIDER_ERROR",
+        "INFERENCE_PROVIDER_RESPONSE_EMPTY",
+        "INFERENCE_PROVIDER_INVALID_JSON",
+        "INFERENCE_PROFILES_MISSING",
+        "INFERENCE_PROFILE_API_KEY_MISSING",
+    ])
+        .nullish(),
+    conflictingRecord: CurrentSlugOwnerSchema.nullish(),
+    detail: z.string().optional(),
+    /** Structured conflict details. Create duplicate reviews and deterministic lookup ambiguity return DuplicateCreateReview; the returned candidates are the decision surface for update, create-with-override, or block. score/threshold rank review priority and are not proof that the requested record is absent. */
+    details: DomainConflictDetailsSchema.nullish(),
+    error: z.record(z.string(), z.string()).nullish(),
+    existingRedirect: RedirectSlugPathSchema.nullish(),
+    feId: z.string().nullish(),
+    field: z.string().nullish(),
+    hammingDistance: z.number().int().nullish(),
+    hint: z.string().nullish(),
+    instance: z.string().optional(),
+    limit: z.number().int().nullish(),
+    limitType: z
+        .enum([
+        "FORM",
+        "GLOBAL",
+        "SUBNET",
+        "IP",
+        "UNKNOWN",
+        "RESILIENCE4J",
+        "WEB_SEARCH",
+        "NATURAL_SEARCH",
+        "BILLING_ALLOWANCE",
+        "CLERK_PUBLIC_ADMISSION",
+        "CLERK_SCRIPT_LOAD",
+        "ORIGIN_DETAIL",
+        "INFERENCE_PROVIDER",
+    ])
+        .nullish(),
+    matchedBlocklistKey: z.string().nullish(),
+    mediaType: z.string().nullish(),
+    moderationReason: z.string().nullish(),
+    parseError: z.string().nullish(),
+    path: z.string().nullish(),
+    properties: z.record(z.string(), JsonValueSchema).optional(),
+    remaining: z.number().int().nullish(),
+    requiredRole: z.string().nullish(),
+    resetAt: z.iso.datetime({ offset: true }).nullish(),
+    resolution: ProblemResolutionSchema.nullish(),
+    retryAfterSeconds: z.number().int().nullish(),
+    spanId: z.string().nullish(),
+    status: z.int().optional(),
+    suggestion: z.string().nullish(),
+    suggestions: z.record(z.string(), z.string()).nullish(),
+    suspectedFragment: z.string().nullish(),
+    title: z.string().optional(),
+    traceId: z.string().nullish(),
+    type: z.string().optional(),
+    unknownParameters: z.array(z.string()).nullish(),
+    used: z.number().int().nullish(),
+    validParameters: z.array(z.string()).nullish(),
+    value: z.string().nullish(),
+    windowSeconds: z.number().int().nullish(),
+});
+/**
+ * RFC 9457 problem response with aVenture extensions.
+ *
+ * @openapiSchema ProblemDetail
+ * @standardProblemResponse
+ * @contractShape http.problem-detail
+ * @contractRole canonical
+ */
+export const ProblemDetailSchema = ProblemDetailSchemaDefinition;
+//# sourceMappingURL=problem-detail.js.map

package/dist/http/status-code.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Canonical HTTP status constants and helpers for downstream consumers.
+ *
+ * Names mirror Spring's HttpStatus enum (SCREAMING_SNAKE) with HTTP_ prefix.
+ * Values are numeric literals from RFC 9110 / RFC 6585 / RFC 7231.
+ *
+ * @shared primitive:multi reusable cross-repo HTTP constant; not generated from OpenAPI
+ * @contractShape http.status-code
+ * @contractRole canonical
+ * @ownerModule http/status-code.ts
+ */
+export declare const HTTP_OK: 200;
+export declare const HTTP_CREATED: 201;
+export declare const HTTP_NO_CONTENT: 204;
+export declare const HTTP_MOVED_PERMANENTLY: 301;
+export declare const HTTP_FOUND: 302;
+export declare const HTTP_TEMPORARY_REDIRECT: 307;
+export declare const HTTP_PERMANENT_REDIRECT: 308;
+export declare const HTTP_BAD_REQUEST: 400;
+export declare const HTTP_UNAUTHORIZED: 401;
+export declare const HTTP_FORBIDDEN: 403;
+export declare const HTTP_NOT_FOUND: 404;
+export declare const HTTP_METHOD_NOT_ALLOWED: 405;
+export declare const HTTP_CONFLICT: 409;
+export declare const HTTP_GONE: 410;
+export declare const HTTP_UNPROCESSABLE_ENTITY: 422;
+export declare const HTTP_TOO_MANY_REQUESTS: 429;
+export declare const HTTP_INTERNAL_SERVER_ERROR: 500;
+export declare const HTTP_NOT_IMPLEMENTED: 501;
+export declare const HTTP_BAD_GATEWAY: 502;
+export declare const HTTP_SERVICE_UNAVAILABLE: 503;
+export declare const HTTP_GATEWAY_TIMEOUT: 504;
+export declare const HTTP_SUCCESS_MIN: 200;
+export declare const HTTP_SUCCESS_MAX: 300;
+export declare const HTTP_REDIRECT_MIN: 300;
+export declare const HTTP_REDIRECT_MAX: 400;
+export declare const HTTP_CLIENT_ERROR_MIN: 400;
+export declare const HTTP_CLIENT_ERROR_MAX: 500;
+export declare const HTTP_SERVER_ERROR_MIN: 500;
+export declare const HTTP_SERVER_ERROR_MAX: 600;
+export declare const isSuccessStatus: (status: number) => boolean;
+export declare const isRedirectStatus: (status: number) => boolean;
+export declare const isClientErrorStatus: (status: number) => boolean;
+export declare const isServerErrorStatus: (status: number) => boolean;
+//# sourceMappingURL=status-code.d.ts.map

package/dist/http/status-code.js

@@ -0,0 +1,46 @@
+// Generated alternate api-schemas support copy from TypeScript source api-schemas/http/status-code.ts
+/**
+ * Canonical HTTP status constants and helpers for downstream consumers.
+ *
+ * Names mirror Spring's HttpStatus enum (SCREAMING_SNAKE) with HTTP_ prefix.
+ * Values are numeric literals from RFC 9110 / RFC 6585 / RFC 7231.
+ *
+ * @shared primitive:multi reusable cross-repo HTTP constant; not generated from OpenAPI
+ * @contractShape http.status-code
+ * @contractRole canonical
+ * @ownerModule http/status-code.ts
+ */
+export const HTTP_OK = 200;
+export const HTTP_CREATED = 201;
+export const HTTP_NO_CONTENT = 204;
+export const HTTP_MOVED_PERMANENTLY = 301;
+export const HTTP_FOUND = 302;
+export const HTTP_TEMPORARY_REDIRECT = 307;
+export const HTTP_PERMANENT_REDIRECT = 308;
+export const HTTP_BAD_REQUEST = 400;
+export const HTTP_UNAUTHORIZED = 401;
+export const HTTP_FORBIDDEN = 403;
+export const HTTP_NOT_FOUND = 404;
+export const HTTP_METHOD_NOT_ALLOWED = 405;
+export const HTTP_CONFLICT = 409;
+export const HTTP_GONE = 410;
+export const HTTP_UNPROCESSABLE_ENTITY = 422;
+export const HTTP_TOO_MANY_REQUESTS = 429;
+export const HTTP_INTERNAL_SERVER_ERROR = 500;
+export const HTTP_NOT_IMPLEMENTED = 501;
+export const HTTP_BAD_GATEWAY = 502;
+export const HTTP_SERVICE_UNAVAILABLE = 503;
+export const HTTP_GATEWAY_TIMEOUT = 504;
+export const HTTP_SUCCESS_MIN = 200;
+export const HTTP_SUCCESS_MAX = 300;
+export const HTTP_REDIRECT_MIN = 300;
+export const HTTP_REDIRECT_MAX = 400;
+export const HTTP_CLIENT_ERROR_MIN = 400;
+export const HTTP_CLIENT_ERROR_MAX = 500;
+export const HTTP_SERVER_ERROR_MIN = 500;
+export const HTTP_SERVER_ERROR_MAX = 600;
+export const isSuccessStatus = (status) => status >= HTTP_SUCCESS_MIN && status < HTTP_SUCCESS_MAX;
+export const isRedirectStatus = (status) => status >= HTTP_REDIRECT_MIN && status < HTTP_REDIRECT_MAX;
+export const isClientErrorStatus = (status) => status >= HTTP_CLIENT_ERROR_MIN && status < HTTP_CLIENT_ERROR_MAX;
+export const isServerErrorStatus = (status) => status >= HTTP_SERVER_ERROR_MIN && status < HTTP_SERVER_ERROR_MAX;
+//# sourceMappingURL=status-code.js.map