@salsita-ai/contracts 0.0.0-stage → 0.49.0-develop.2a2e8d75e7

package/dist/webhook/tasks/publish-revision-chunks-staged-task.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { RevisionId } from '../../domain/index.js';
+import { TaskType } from '../core/index.js';
+import { ChunkDefinition } from './publish-revision-chunks-task.js';
+/**
+ * Shape of the object a current SDK webhook uploads to the server-provided finalization staging URL.
+ *
+ * Connected-data chunks are staged in S3 instead of being returned inline because the project webhook runs in a
+ * Lambda whose synchronous response is capped at 6 MiB, and a large connected dataset exceeds that on its own. The
+ * `version` literal guards future format changes: the server rejects a staged object it cannot parse instead of
+ * publishing something it misread.
+ */
+export interface PublishRevisionChunksStagedData {
+    readonly version: 1;
+    readonly chunks: readonly ChunkDefinition[];
+}
+export declare const PublishRevisionChunksStagedData: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    chunks: z.ZodArray<z.ZodObject<{
+        key: z.ZodEffects<z.ZodString, import("../../domain/index.js").ChunkKey, string>;
+        scope: z.ZodEffects<z.ZodString, import("../../domain/index.js").ChunkScope, string>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        key: string & import("@salsita-ai/common/utils").Brand<"ChunkKey">;
+        scope: string & import("@salsita-ai/common/utils").Brand<"ChunkScope">;
+        data: Record<string, unknown>;
+    }, {
+        key: string;
+        scope: string;
+        data: Record<string, unknown>;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    chunks: {
+        key: string & import("@salsita-ai/common/utils").Brand<"ChunkKey">;
+        scope: string & import("@salsita-ai/common/utils").Brand<"ChunkScope">;
+        data: Record<string, unknown>;
+    }[];
+}, {
+    version: 1;
+    chunks: {
+        key: string;
+        scope: string;
+        data: Record<string, unknown>;
+    }[];
+}>;
+/**
+ * Lightweight publish task a current SDK webhook returns after it staged the chunks; the server publishes them from
+ * the staging object.
+ *
+ * Compatibility holds in both directions. An older SDK ignores the staging URL and returns the inline
+ * `PublishRevisionChunks` task, which servers keep accepting. A current SDK called by an older server receives no
+ * staging URL and falls back to that same inline task.
+ */
+export interface PublishRevisionChunksStagedTask {
+    readonly type: typeof TaskType.PublishRevisionChunksStaged;
+    readonly revisionId: RevisionId;
+    readonly publishedDataHash: string;
+}
+export declare const PublishRevisionChunksStagedTask: z.ZodObject<{
+    type: z.ZodLiteral<"PublishRevisionChunksStaged">;
+    revisionId: z.ZodEffects<z.ZodString, RevisionId, string>;
+    publishedDataHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "PublishRevisionChunksStaged";
+    revisionId: string & import("@salsita-ai/common/utils").Brand<"RevisionId">;
+    publishedDataHash: string;
+}, {
+    type: "PublishRevisionChunksStaged";
+    revisionId: string;
+    publishedDataHash: string;
+}>;
+export declare const createPublishRevisionChunksStagedTask: (task: PublishRevisionChunksStagedTask) => PublishRevisionChunksStagedTask;

package/dist/webhook/tasks/publish-revision-chunks-staged-task.js

@@ -0,0 +1 @@
+import{z as s}from"zod";import{usingType as i}from"@salsita-ai/common/utils";import{RevisionId as o}from"../../domain/index.js";import{TaskType as t}from"../core/index.js";import{ChunkDefinition as r}from"./publish-revision-chunks-task.js";export const PublishRevisionChunksStagedData=s.object({version:s.literal(1),chunks:s.array(r)});export const PublishRevisionChunksStagedTask=s.object({type:s.literal(t.PublishRevisionChunksStaged),revisionId:s.string().transform(i(o)),publishedDataHash:s.string()});export const createPublishRevisionChunksStagedTask=s=>s;

package/dist/webhook/tasks/publish-revision-chunks-task.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { ChunkKey, ChunkScope, RevisionId } from '../../domain/index.js';
+import { TaskType } from '../core/index.js';
+/**
+ * Definition of a single chunk to be published
+ */
+export interface ChunkDefinition {
+    readonly key: ChunkKey;
+    readonly scope: ChunkScope;
+    readonly data: Record<string, unknown>;
+}
+export declare const ChunkDefinition: z.ZodObject<{
+    key: z.ZodEffects<z.ZodString, ChunkKey, string>;
+    scope: z.ZodEffects<z.ZodString, ChunkScope, string>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    key: string & import("@salsita-ai/common/utils").Brand<"ChunkKey">;
+    scope: string & import("@salsita-ai/common/utils").Brand<"ChunkScope">;
+    data: Record<string, unknown>;
+}, {
+    key: string;
+    scope: string;
+    data: Record<string, unknown>;
+}>;
+/**
+ * Publishes revision with chunked data to private S3 with scope-based access control
+ */
+export interface PublishRevisionChunksTask {
+    readonly type: typeof TaskType.PublishRevisionChunks;
+    /**
+     * The unique identifier of the revision to be published
+     */
+    readonly revisionId: RevisionId;
+    /**
+     * Chunks of data to be published, each with its own scope
+     */
+    readonly chunks: readonly ChunkDefinition[];
+    readonly publishedDataHash: string;
+}
+export declare const PublishRevisionChunksTask: z.ZodObject<{
+    type: z.ZodLiteral<"PublishRevisionChunks">;
+    revisionId: z.ZodEffects<z.ZodString, RevisionId, string>;
+    chunks: z.ZodArray<z.ZodObject<{
+        key: z.ZodEffects<z.ZodString, ChunkKey, string>;
+        scope: z.ZodEffects<z.ZodString, ChunkScope, string>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        key: string & import("@salsita-ai/common/utils").Brand<"ChunkKey">;
+        scope: string & import("@salsita-ai/common/utils").Brand<"ChunkScope">;
+        data: Record<string, unknown>;
+    }, {
+        key: string;
+        scope: string;
+        data: Record<string, unknown>;
+    }>, "many">;
+    publishedDataHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "PublishRevisionChunks";
+    revisionId: string & import("@salsita-ai/common/utils").Brand<"RevisionId">;
+    chunks: {
+        key: string & import("@salsita-ai/common/utils").Brand<"ChunkKey">;
+        scope: string & import("@salsita-ai/common/utils").Brand<"ChunkScope">;
+        data: Record<string, unknown>;
+    }[];
+    publishedDataHash: string;
+}, {
+    type: "PublishRevisionChunks";
+    revisionId: string;
+    chunks: {
+        key: string;
+        scope: string;
+        data: Record<string, unknown>;
+    }[];
+    publishedDataHash: string;
+}>;
+export declare const createPublishRevisionChunksTask: (task: PublishRevisionChunksTask) => PublishRevisionChunksTask;

package/dist/webhook/tasks/publish-revision-chunks-task.js

@@ -0,0 +1 @@
+import{z as i}from"zod";import{usingType as o}from"@salsita-ai/common/utils";import{ChunkKey as n,ChunkScope as s,RevisionId as r}from"../../domain/index.js";import{TaskType as t}from"../core/index.js";export const ChunkDefinition=i.object({key:i.string().transform(o(n)),scope:i.string().transform(o(s)),data:i.record(i.unknown())});export const PublishRevisionChunksTask=i.object({type:i.literal(t.PublishRevisionChunks),revisionId:i.string().transform(o(r)),chunks:i.array(ChunkDefinition),publishedDataHash:i.string()});export const createPublishRevisionChunksTask=i=>i;

package/dist/webhook/tasks/publish-revision-task.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { PublishedDataRevisionVersion, RevisionId } from '../../domain/index.js';
+import { TaskType } from '../core/index.js';
+/**
+ * Publishes a revision that may be publicly accessible by applications
+ */
+export interface PublishRevisionTask {
+    readonly type: typeof TaskType.PublishRevision;
+    /**
+     * Version of the data used to check compatibility of the server and deployed workers, BUMP IT UP WHEN introducing breaking CHANGING THE SCHEMA!!!!
+     */
+    readonly version: PublishedDataRevisionVersion;
+    /**
+     * The unique identifier of the revision to be published
+     */
+    readonly revisionId: RevisionId;
+    /**
+     * Data that will be published with the revision, these may be public, so be careful with sensitive data!
+     */
+    readonly data: object;
+}
+export declare const PublishRevisionTask: z.ZodObject<{
+    type: z.ZodLiteral<"PublishRevision">;
+    version: z.ZodEffects<z.ZodNumber, PublishedDataRevisionVersion, number>;
+    revisionId: z.ZodEffects<z.ZodString, RevisionId, string>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "PublishRevision";
+    version: number & import("@salsita-ai/common/utils").Brand<"PublishedDataRevisionVersion">;
+    revisionId: string & import("@salsita-ai/common/utils").Brand<"RevisionId">;
+    data: Record<string, unknown>;
+}, {
+    type: "PublishRevision";
+    version: number;
+    revisionId: string;
+    data: Record<string, unknown>;
+}>;
+export declare const createPublishRevisionTask: (task: PublishRevisionTask) => PublishRevisionTask;

package/dist/webhook/tasks/publish-revision-task.js

@@ -0,0 +1 @@
+import{z as o}from"zod";import{usingType as i}from"@salsita-ai/common/utils";import{PublishedDataRevisionVersion as r,RevisionId as s}from"../../domain/index.js";import{TaskType as n}from"../core/index.js";export const PublishRevisionTask=o.object({type:o.literal(n.PublishRevision),version:o.number().transform(i(r)),revisionId:o.string().transform(i(s)),data:o.record(o.unknown())});export const createPublishRevisionTask=o=>o;

package/dist/webhook/tasks/send-email-task.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { type FinalizeTaskResource, StoredTemplate, TaskType, Template, TemplateResource } from '../core/index.js';
+export interface ResourceEmailAttachment {
+    /**
+     * Type of the attachment.
+     * "resource" attachments are refenrencing a pre-defined resource, which is usually generated by some other task, like a PDF or CSV.
+     */
+    type?: 'resource';
+    /** filename to be reported as the name of the attached file */
+    filename: string;
+    /**
+     * Name of the resource (from the FinalTasks's definition) to be included in the email as a content of the attachment
+     * This can be either image, pdf or csv
+     */
+    resource: string;
+}
+export declare const ResourceEmailAttachment: z.ZodType<ResourceEmailAttachment>;
+export interface Base64EmailAttachment {
+    /**
+     * Type of the attachment.
+     * "base64" attachments can be created dynamically in the email task. Source of the data can for example be data from prefetch task.
+     */
+    type: 'base64';
+    /** filename to be reported as the name of the attached file */
+    filename: string;
+    /**
+     * Base64 encoded data of the attachment
+     */
+    data: string;
+}
+export declare const Base64EmailAttachment: z.ZodType<Base64EmailAttachment>;
+export type EmailAttachment = ResourceEmailAttachment | Base64EmailAttachment;
+export declare const EmailAttachment: z.ZodType<EmailAttachment>;
+export interface SendEmailTask {
+    type: typeof TaskType.SendEmail;
+    /**
+     * The email address of the sender. All email addresses can be plain ‘sender@server.com’ or formatted '“Sender Name” sender@server.com'
+     */
+    from: string;
+    /**
+     * Comma separated list or an array of recipients email addresses that will appear on the To: field
+     */
+    to: string;
+    /**
+     * Comma separated list or an array of recipients email addresses that will appear on the Cc: field
+     */
+    cc: string;
+    /**
+     * Comma separated list or an array of recipients email addresses that will appear on the Bcc: field
+     */
+    bcc: string;
+    /**
+     * Optional address that recipients see in the Reply-To header. When unset, replies go to `from`.
+     * Useful when emails are sent from an authorized no-reply / generic sender but replies should land elsewhere
+     * (e.g. customer enquiries replying back to the customer, or a tenant-specific support address behind a shared sender).
+     */
+    replyTo?: string;
+    /**
+     * The subject of the email
+     */
+    subject: string;
+    /**
+     * The plaintext version of the message
+     */
+    text: string;
+    /**
+     * Html version of the email to be compiled using Handlebars template
+     */
+    html: StoredTemplate | Template;
+    /**
+     * An array of attachments to add to the email
+     */
+    attachments: EmailAttachment[];
+}
+export declare const SendEmailTask: z.ZodType<SendEmailTask>;
+export interface SendStaticEmailTask {
+    type: typeof TaskType.SendStaticEmail;
+    /**
+     * The email address of the sender. All email addresses can be plain ‘sender@server.com’ or formatted '“Sender Name” sender@server.com'
+     */
+    from: string;
+    /**
+     * Comma separated list or an array of recipients email addresses that will appear on the To: field
+     */
+    to: string;
+    /**
+     * Comma separated list or an array of recipients email addresses that will appear on the Cc: field
+     */
+    cc: string | null;
+    /**
+     * Comma separated list or an array of recipients email addresses that will appear on the Bcc: field
+     */
+    bcc: string | null;
+    /**
+     * Optional address that recipients see in the Reply-To header. When unset, replies go to `from`.
+     * Useful when emails are sent from an authorized no-reply / generic sender but replies should land elsewhere
+     * (e.g. customer enquiries replying back to the customer, or a tenant-specific support address behind a shared sender).
+     */
+    replyTo: string | null;
+    /**
+     * The subject of the email
+     */
+    subject: string;
+    /**
+     * The plaintext version of the message
+     *
+     * `configuration-resource://{name}` occurrences will be replaced with the content of the resource with the given name.
+     * The referenced resource must be listed in the `includeResources` array.
+     */
+    text: string;
+    /**
+     * Html version of the email as a string
+     *
+     * `configuration-resource://{name}` occurrences will be replaced with the content of the resource with the given name.
+     * The referenced resource must be listed in the `includeResources` array.
+     */
+    html: string;
+    /**
+     * An array of attachments to add to the email
+     */
+    attachments: readonly EmailAttachment[];
+    /**
+     * The resources ready to be included in the email either as a link, image source or a standalone attachment.
+     */
+    includeResources: readonly TemplateResource[];
+}
+export declare const SendStaticEmailTask: z.ZodType<SendStaticEmailTask>;
+export declare const validateSendEmailTask: (task: SendEmailTask, resources: FinalizeTaskResource[]) => void;
+export declare const validateSendStaticEmailTask: (task: SendStaticEmailTask, resources: FinalizeTaskResource[]) => void;

package/dist/webhook/tasks/send-email-task.js

@@ -0,0 +1 @@
+import{z as e}from"zod";import{StoredTemplate as t,TaskType as r,Template as i,TemplateResource as a,validateTemplate as n}from"../core/index.js";export const ResourceEmailAttachment=e.object({type:e.literal("resource").optional(),filename:e.string(),resource:e.string()});export const Base64EmailAttachment=e.object({type:e.literal("base64"),filename:e.string(),data:e.string()});export const EmailAttachment=e.union([ResourceEmailAttachment,Base64EmailAttachment]);export const SendEmailTask=e.object({type:e.literal(r.SendEmail),from:e.string(),to:e.string(),cc:e.string(),bcc:e.string(),replyTo:e.string().optional(),subject:e.string(),text:e.string(),html:e.union([t,i]),attachments:e.array(EmailAttachment)});export const SendStaticEmailTask=e.object({type:e.literal(r.SendStaticEmail),from:e.string(),to:e.string(),cc:e.string().nullable(),bcc:e.string().nullable(),replyTo:e.string().nullable(),subject:e.string(),text:e.string(),html:e.string(),attachments:e.array(EmailAttachment),includeResources:e.array(a)});let o=(e,t)=>{if("resource"===e.type||void 0===e.type){if(null==t.find(t=>t.name===e.resource))throw Error(`The provided FinalizeTask configuration is invalid! Resource ${e.resource} is not declared in the resources. Provide a resource with the name ${e.resource}.`)}else if("base64"===e.type&&"string"!=typeof e.data)throw Error("The provided FinalizeTask configuration is invalid! Base64 attachment data is not a string.")};export const validateSendEmailTask=(e,t)=>{n(e.html,t),e.attachments.forEach(e=>{o(e,t)})};export const validateSendStaticEmailTask=(e,t)=>{e.includeResources.forEach(e=>{if(null==t.find(t=>t.name===e.name))throw Error(`The provided FinalizeTask configuration is invalid! Static email includeResources references "${e.name}" which is not declared in the resources. Declare it or remove the reference.`)}),e.attachments.forEach(e=>{o(e,t)})};

package/dist/webhook/tasks/send-http-task.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { TaskType, Template } from '../core/index.js';
+/**
+ * The SendHttpRequest is used to send an HTTP request to a given URL with the given method, headers and body.
+ * For now it does not support use of generated resources as part of the request.
+ * The task is run as the last task in the finalize configuration flow.
+ */
+export interface SendHttpRequestTask {
+    type: typeof TaskType.SendHttpRequest;
+    /**
+     * The URL to send the request to
+     */
+    url: string;
+    /**
+     * The HTTP method to use, defaults to GET
+     */
+    method?: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH' | undefined;
+    /**
+     * The headers to send with the request
+     */
+    headers?: Record<string, string> | undefined;
+    /**
+     * The body of the request, (stringified JSON, template or raw text)
+     */
+    body?: string | undefined | Template;
+}
+export declare const SendHttpRequestTask: z.ZodType<SendHttpRequestTask>;

package/dist/webhook/tasks/send-http-task.js

@@ -0,0 +1 @@
+import{z as t}from"zod";import{TaskType as e,Template as l}from"../core/index.js";export const SendHttpRequestTask=t.object({type:t.literal(e.SendHttpRequest),url:t.string(),method:t.union([t.literal("GET"),t.literal("HEAD"),t.literal("POST"),t.literal("PUT"),t.literal("DELETE"),t.literal("CONNECT"),t.literal("OPTIONS"),t.literal("TRACE"),t.literal("PATCH")]).optional(),headers:t.record(t.string()).optional(),body:t.union([t.string(),l]).optional()});

package/dist/webhook/tasks/woocommerce-add-to-cart-task.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { type ValueOf } from '@salsita-ai/common/utils';
+import { TaskResourceType, TaskType } from '../core/index.js';
+export interface WooCommerceAddToCartResource {
+    /**
+     * Type of the resource
+     */
+    type: TaskResourceType;
+    /**
+     * Name slug of the resource
+     */
+    name: string;
+    /**
+     * Label to show in the order and email
+     */
+    label: string;
+}
+export declare const WooCommerceAddToCartResource: z.ZodType<WooCommerceAddToCartResource>;
+export interface WooCommerceAddToCartItem {
+    /**
+     * The product to add to the cart
+     */
+    product: string;
+    /**
+     * The name of the product
+     */
+    productName?: string;
+    /**
+     * The product description
+     */
+    productDescription?: string;
+    /**
+     * The price of the product
+     */
+    price?: number;
+    /**
+     * The quantity of the product to add to the cart
+     */
+    quantity?: number;
+    /**
+     * Optional URL of product image
+     */
+    image?: string;
+    /**
+     * Optional custom data object (e.g., shipping info, dimensions, etc.)
+     * This will be stored as cart item data with 'salsita_' prefix and accessible in WooCommerce.
+     */
+    customData?: Record<string, unknown>;
+    /**
+     * Optional resources to add to the cart
+     */
+    resources?: WooCommerceAddToCartResource[];
+}
+export declare const WooCommerceAddToCartItem: z.ZodType<WooCommerceAddToCartItem>;
+export declare const WooCommerceAddToCartFeeType: {
+    readonly Flat: 'Flat';
+    readonly Percentage: 'Percentage';
+};
+export type WooCommerceAddToCartFeeType = ValueOf<typeof WooCommerceAddToCartFeeType>;
+export interface WooCommerceAddToCartFee {
+    type: WooCommerceAddToCartFeeType;
+    name: string;
+    amount: number;
+    taxable?: boolean;
+    taxClass?: string;
+}
+export declare const WooCommerceAddToCartFee: z.ZodType<WooCommerceAddToCartFee>;
+export interface WooCommerceAddToCartTask {
+    type: typeof TaskType.WooCommerceAddToCart;
+    /**
+     * The items to add to the cart
+     */
+    items: WooCommerceAddToCartItem[];
+    /**
+     * Optional fees to add to the cart
+     */
+    fees?: WooCommerceAddToCartFee[];
+    /**
+     * Session data
+     */
+    session: string;
+    /**
+     * Add to Cart URL
+     */
+    addToCartUrl: string;
+    /**
+     * API key
+     */
+    apiKey: string;
+}
+export declare const WooCommerceAddToCartTask: z.ZodType<WooCommerceAddToCartTask>;

package/dist/webhook/tasks/woocommerce-add-to-cart-task.js

@@ -0,0 +1 @@
+import{z as o}from"zod";import{TaskResourceType as e,TaskType as t}from"../core/index.js";export const WooCommerceAddToCartResource=o.object({type:o.union([o.literal(e.Image),o.literal(e.Pdf),o.literal(e.Csv),o.literal(e.ConfigurationLink)]),name:o.string(),label:o.string()});export const WooCommerceAddToCartItem=o.object({product:o.string(),productName:o.string().optional(),productDescription:o.string().optional(),price:o.number().optional(),quantity:o.number().optional(),image:o.string().optional(),customData:o.record(o.string(),o.unknown()).optional(),resources:o.array(WooCommerceAddToCartResource).optional()});export const WooCommerceAddToCartFeeType={Flat:"Flat",Percentage:"Percentage"};export const WooCommerceAddToCartFee=o.object({type:o.nativeEnum(WooCommerceAddToCartFeeType),name:o.string(),amount:o.number(),taxable:o.boolean().optional(),taxClass:o.string().optional()});export const WooCommerceAddToCartTask=o.object({type:o.literal(t.WooCommerceAddToCart),items:o.array(WooCommerceAddToCartItem),fees:o.array(WooCommerceAddToCartFee).optional(),session:o.string(),addToCartUrl:o.string(),apiKey:o.string()});

package/dist/webhook/webhook-payload.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import type { Entity } from '../domain/index.js';
+import { ConfigurationId, DeploymentId, FrontendUrl, RevisionId } from '../domain/index.js';
+export interface FinalizeWebhookPayload<FINALIZE_DATA, ENTITIES> {
+    configurationId: ConfigurationId;
+    revisionId: RevisionId;
+    deploymentId: DeploymentId;
+    frontendUrl: FrontendUrl;
+    rootEntityType: Entity['type'];
+    entities: ENTITIES[];
+    modelVersion: number;
+    data: FINALIZE_DATA;
+}
+export declare const FinalizeWebhookPayload: z.ZodObject<{
+    configurationId: z.ZodEffects<z.ZodString, ConfigurationId, string>;
+    revisionId: z.ZodEffects<z.ZodString, RevisionId, string>;
+    deploymentId: z.ZodEffects<z.ZodString, DeploymentId, string>;
+    frontendUrl: z.ZodEffects<z.ZodString, FrontendUrl, string>;
+    rootEntityType: z.ZodString;
+    entities: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        id: string;
+    }, {
+        type: string;
+        id: string;
+    }>, "many">;
+    modelVersion: z.ZodNumber;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    configurationId: string & import("@salsita-ai/common/utils").Brand<"ConfigurationId">;
+    revisionId: string & import("@salsita-ai/common/utils").Brand<"RevisionId">;
+    deploymentId: string & import("@salsita-ai/common/utils").Brand<"DeploymentId">;
+    frontendUrl: string & import("@salsita-ai/common/utils").Brand<"FrontendUrl">;
+    rootEntityType: string;
+    entities: {
+        type: string;
+        id: string;
+    }[];
+    modelVersion: number;
+    data: Record<string, unknown>;
+}, {
+    configurationId: string;
+    revisionId: string;
+    deploymentId: string;
+    frontendUrl: string;
+    rootEntityType: string;
+    entities: {
+        type: string;
+        id: string;
+    }[];
+    modelVersion: number;
+    data: Record<string, unknown>;
+}>;

package/dist/webhook/webhook-payload.js

@@ -0,0 +1 @@
+import{z as o}from"zod";import{usingType as r}from"@salsita-ai/common/utils";import{ConfigurationId as t,DeploymentId as n,FrontendUrl as i,RevisionId as s}from"../domain/index.js";export const FinalizeWebhookPayload=o.object({configurationId:o.string().transform(r(t)),revisionId:o.string().transform(r(s)),deploymentId:o.string().transform(r(n)),frontendUrl:o.string().transform(r(i)),rootEntityType:o.string(),entities:o.array(o.object({type:o.string(),id:o.string()})),modelVersion:o.number().positive(),data:o.record(o.unknown())});

package/package.json

@@ -1,6 +1,87 @@
 {
   "name": "@salsita-ai/contracts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.49.0-develop.2a2e8d75e7",
+  "description": "Shared API, authentication, domain, chat, and webhook contracts for Phoenix.",
+  "keywords": [
+    "salsita",
+    "3d",
+    "configurator",
+    "phoenix",
+    "platform"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    "./api": {
+      "import": "./dist/api/index.js",
+      "types": "./dist/api/index.d.ts"
+    },
+    "./clerk": {
+      "import": "./dist/clerk/index.js",
+      "types": "./dist/clerk/index.d.ts"
+    },
+    "./domain": {
+      "import": "./dist/domain/index.js",
+      "types": "./dist/domain/index.d.ts"
+    },
+    "./chat": {
+      "import": "./dist/chat/index.js",
+      "types": "./dist/chat/index.d.ts"
+    },
+    "./assistant": {
+      "import": "./dist/assistant/index.js",
+      "types": "./dist/assistant/index.d.ts"
+    },
+    "./webhook": {
+      "import": "./dist/webhook/index.js",
+      "types": "./dist/webhook/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@tanstack/ai": "0.64.0",
+    "@types/aws-lambda": "8.10.133",
+    "ajv": "8.20.0",
+    "http-errors": "2.0.1",
+    "jose": "6.2.3",
+    "lodash-es": "4.18.1",
+    "openai": "7.23.0",
+    "ts-pattern": "5.9.0",
+    "uuid": "14.0.0",
+    "valid-url": "1.0.9",
+    "zod": "3.25.76",
+    "@salsita-ai/common": "0.49.0-develop.2a2e8d75e7"
+  },
+  "devDependencies": {
+    "@lingui/core": "5.9.5",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.40",
+    "@types/http-errors": "2.0.5",
+    "@types/json-schema": "7.0.15",
+    "@types/lodash-es": "4.17.12",
+    "@types/valid-url": "1.0.7",
+    "eslint": "9.39.4",
+    "prettier": "3.8.3",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vite": "6.4.3",
+    "vitest": "4.1.11"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc --project ./tsconfig.build.json --emitDeclarationOnly --checkers 1 && swc src --out-dir dist --strip-leading-paths",
+    "clean": "rm -rf dist && rm -rf node_modules",
+    "dev": "swc src --out-dir dist --watch --strip-leading-paths & tsc --project ./tsconfig.build.json --emitDeclarationOnly --watch --checkers 1",
+    "transpile": "swc src --out-dir dist --strip-leading-paths",
+    "lint:check": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "prettify:check": "prettier --check .",
+    "prettify:fix": "prettier --write .",
+    "test": "vitest run",
+    "ts:check": "tsc --project ./tsconfig.build.json --noEmit --checkers 1"
+  }
 }