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

package/dist/domain/deployments/oauth-connection-domain.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { Branded } from '@salsita-ai/common/utils';
+import { type ProjectId } from './project-domain.js';
+export type OAuthConnectionId = Branded<'OAuthConnectionId', string>;
+export declare const OAuthConnectionId: (id: string) => OAuthConnectionId;
+/**
+ * Providers that use a per-user OAuth connection (refresh token persisted
+ * server-side). Microsoft is NOT here — Microsoft uses app-only auth
+ * (client_credentials) and is bound per project instead, see
+ * `SharePointProjectSite`.
+ */
+export type OAuthConnectionProvider = 'google';
+export type OAuthRefreshToken = Branded<'OAuthRefreshToken', string>;
+export declare const OAuthRefreshToken: (token: string) => OAuthRefreshToken;
+export type OAuthGrantedScopes = Branded<'OAuthGrantedScopes', readonly string[]>;
+export declare const OAuthGrantedScopes: (scopes: readonly string[]) => OAuthGrantedScopes;
+export declare const OAUTH_STALE_CONNECTION_CODE: 'STALE_CONNECTION';
+export declare const SHAREPOINT_MISSING_TENANT_DOMAIN: 'fill-in-tenant-domain.invalid';
+export declare class SharePointTenantDomainInvalidError extends Error {
+    readonly code: 'tenant_domain_invalid';
+    constructor(tenantDomain: string, reason: string);
+}
+export declare const parseSharePointTenantDomain: (rawDomain: string) => string | null;
+export declare const parseRequiredSharePointTenantDomain: (rawDomain: string) => string;
+export declare const SharePointTenantDomainSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Per-project SharePoint site binding, independent of the user OAuth
+ * connection model used by Google — Microsoft uses app-only auth
+ * (client_credentials) and needs no per-user refresh token.
+ *
+ * `tenantId` is required because Microsoft's token endpoint can't use
+ * `/common/` for client_credentials — a specific tenant is needed in the
+ * URL. Resolved per-project by the studio wizard from a tenant domain (e.g.
+ * `contoso.onmicrosoft.com`) via OpenID discovery.
+ */
+export interface SharePointProjectSite {
+    readonly projectId: ProjectId;
+    readonly tenantId: string;
+    readonly tenantDomain: string;
+    readonly siteUrl: string;
+    readonly siteId: string;
+    readonly displayName: string | null;
+}
+export interface NewOAuthConnection {
+    readonly projectId: ProjectId;
+    readonly provider: OAuthConnectionProvider;
+    readonly refreshToken: string;
+    readonly grantedScopes: readonly string[];
+    readonly connectedEmail: string | null;
+    readonly isStale: boolean;
+}
+export interface OAuthConnection {
+    readonly id: OAuthConnectionId;
+    readonly projectId: ProjectId;
+    readonly provider: OAuthConnectionProvider;
+    readonly refreshToken: OAuthRefreshToken;
+    readonly grantedScopes: OAuthGrantedScopes;
+    readonly connectedEmail: string | null;
+    readonly isStale: boolean;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}

package/dist/domain/deployments/oauth-connection-domain.js

@@ -0,0 +1 @@
+import{validate as n}from"uuid";import{z as o}from"zod";import{Branded as t}from"@salsita-ai/common/utils";export const OAuthConnectionId=o=>{if(!n(o))throw Error(`Invalid OAuthConnection id: ${o}. It must be a valid UUID.`);return t(o)};export const OAuthRefreshToken=n=>t(n);export const OAuthGrantedScopes=n=>t(n);export const OAUTH_STALE_CONNECTION_CODE="STALE_CONNECTION";export const SHAREPOINT_MISSING_TENANT_DOMAIN="fill-in-tenant-domain.invalid";let e=/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/i;export class SharePointTenantDomainInvalidError extends Error{code="tenant_domain_invalid";constructor(n,o){super(`SharePoint tenant domain '${n}' is invalid. ${o}. Use a verified Azure AD tenant domain, e.g. 'contoso.onmicrosoft.com'.`),this.name="SharePointTenantDomainInvalidError"}}export const parseSharePointTenantDomain=n=>{let o=n.trim().toLowerCase();return o&&e.test(o)?o:null};export const parseRequiredSharePointTenantDomain=n=>{let o=parseSharePointTenantDomain(n);if(null===o)throw new SharePointTenantDomainInvalidError(n,"Expected a domain name");if("fill-in-tenant-domain.invalid"===o)throw new SharePointTenantDomainInvalidError(n,"This value is a migration placeholder");return o};export const SharePointTenantDomainSchema=o.string().transform((n,t)=>{try{return parseRequiredSharePointTenantDomain(n)}catch(n){if(n instanceof SharePointTenantDomainInvalidError)return t.addIssue({code:o.ZodIssueCode.custom,message:"Expected a verified Azure AD tenant domain, e.g. contoso.onmicrosoft.com."}),o.NEVER;throw n}});

package/dist/domain/deployments/oauth-provider-domain.d.ts

@@ -0,0 +1,23 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type CustomerId } from './customer-domain.js';
+export type OAuthProviderId = Branded<'OAuthProviderId', string>;
+export declare const OAuthProviderId: (id: string) => OAuthProviderId;
+export type OAuthProviderName = Branded<'OAuthProviderName', string>;
+export declare const OAuthProviderName: (name: string) => OAuthProviderName;
+export type OAuthBaseUrl = Branded<'OAuthBaseUrl', string>;
+export declare const OAuthBaseUrl: (url: string) => OAuthBaseUrl;
+export type OAuthClientId = Branded<'OAuthClientId', string>;
+export declare const OAuthClientId: (id: string) => OAuthClientId;
+export type OAuthClientSecret = Branded<'OAuthClientSecret', string>;
+export declare const OAuthClientSecret: (secret: string) => OAuthClientSecret;
+export type OAuthScopes = Branded<'OAuthScopes', string[]>;
+export declare const OAuthScopes: (scopes: string[]) => OAuthScopes;
+export interface OAuthProvider {
+    id: OAuthProviderId;
+    customerId: CustomerId;
+    name: OAuthProviderName;
+    baseUrl: OAuthBaseUrl;
+    clientId: OAuthClientId;
+    clientSecret: OAuthClientSecret;
+    scopes: OAuthScopes;
+}

package/dist/domain/deployments/oauth-provider-domain.js

@@ -0,0 +1 @@
+import{validate as t}from"uuid";import{Branded as o}from"@salsita-ai/common/utils";export const OAuthProviderId=r=>{if(!t(r))throw Error(`Invalid Project id: ${r}. It must be a valid UUID.`);return o(r)};export const OAuthProviderName=t=>o(t);export const OAuthBaseUrl=t=>o(t);export const OAuthClientId=t=>o(t);export const OAuthClientSecret=t=>o(t);export const OAuthScopes=t=>o(t);

package/dist/domain/deployments/project-domain.d.ts

@@ -0,0 +1,26 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type CustomerId } from './customer-domain.js';
+export type ProjectId = Branded<'ProjectId', string>;
+export declare const ProjectId: (id: string) => ProjectId;
+export type ProjectName = Branded<'ProjectName', string>;
+export declare const ProjectName: (name: string) => ProjectName;
+/**
+ * What a project's application spec writes as `project` to mean "the default project of the customer I am signed in
+ * to". The server resolves it for an API token's customer, so a starter project runs in any workspace without naming
+ * a real project. It is not a project slug: no project may be created with it.
+ */
+export declare const DEFAULT_PROJECT_ALIAS = "default";
+export type ProjectSlug = Branded<'ProjectSlug', string>;
+export declare const ProjectSlug: (slug: string) => ProjectSlug;
+export type ParamStorePath = Branded<'ParamStorePath', string>;
+export declare const ParamStorePath: (path: string) => ParamStorePath;
+export type ProjectCustomDomain = Branded<'ProjectCustomDomain', string>;
+export declare const ProjectCustomDomain: (url: string) => ProjectCustomDomain;
+export interface Project {
+    readonly id: ProjectId;
+    readonly customerId: CustomerId;
+    readonly name: ProjectName;
+    readonly slug: ProjectSlug;
+    readonly paramStorePath: ParamStorePath;
+    readonly customDomain: ProjectCustomDomain | null;
+}

package/dist/domain/deployments/project-domain.js

@@ -0,0 +1 @@
+import{validate as r}from"uuid";import{isWebUri as o}from"valid-url";import{Branded as t}from"@salsita-ai/common/utils";export const ProjectId=o=>{if(!r(o))throw Error(`Invalid Project id: ${o}. It must be a valid UUID.`);return t(o)};export const ProjectName=r=>t(r);export const DEFAULT_PROJECT_ALIAS="default";export const ProjectSlug=r=>{let o=r.trim();if(0===o.length)throw Error("Project slug cannot be empty, project slug is required for repository and domain creation, please provide a valid slug.");if(o.length<3)throw Error("Project slug is too short, project slug must be at least 3 characters long, please provide a longer slug.");if(!/^[a-z0-9-]+$/.test(o))throw Error("Project slug format is invalid, project slug must contain only lowercase letters, numbers, and hyphens, please provide a valid slug.");return t(o)};export const ParamStorePath=r=>t(r);export const ProjectCustomDomain=r=>{let e=r.trim();if(0===e.length)throw Error("Custom domain cannot be empty, please provide a valid URL or leave it unset.");if(!o(e))throw Error("Custom domain format is invalid, could not parse as valid web URI, please provide a valid URL format.");return t(e)};

package/dist/domain/deployments/sdk-builder-setup-domain.d.ts

@@ -0,0 +1,13 @@
+import type { ValueOf } from '@salsita-ai/common/utils';
+/**
+ * Where the setup of an SDK builder's workspace is. Setup is the init build that deploys the hello-world starter to
+ * the workspace's one environment: it is still running (`pending`), it made the environment live (`ready`), or it
+ * ended or timed out without a live deployment and can be retried (`failed`). The server derives it for the builder
+ * Studio's overview and to decide whether a setup retry is allowed.
+ */
+export declare const SdkBuilderSetupState: {
+    readonly Pending: 'pending';
+    readonly Ready: 'ready';
+    readonly Failed: 'failed';
+};
+export type SdkBuilderSetupState = ValueOf<typeof SdkBuilderSetupState>;

package/dist/domain/deployments/sdk-builder-setup-domain.js

@@ -0,0 +1 @@
+export const SdkBuilderSetupState={Pending:"pending",Ready:"ready",Failed:"failed"};

package/dist/domain/deployments/session-domain.d.ts

@@ -0,0 +1,20 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { DeploymentId } from './deployment-domain.js';
+import type { EnvironmentId } from './environment-domain.js';
+export type BucketTimestamp = Branded<'BucketTimestamp', Date>;
+export declare const BucketTimestamp: (date: Date) => BucketTimestamp;
+export type SessionCount = Branded<'SessionCount', number>;
+export declare const SessionCount: (count: number) => SessionCount;
+export interface SessionBucket {
+    readonly environmentId: EnvironmentId;
+    readonly deploymentId: DeploymentId;
+    readonly bucketTimestamp: BucketTimestamp;
+    readonly sessionCount: SessionCount;
+}
+export interface NewSessionBucket {
+    readonly environmentId: EnvironmentId;
+    readonly deploymentId: DeploymentId;
+    readonly bucketTimestamp: BucketTimestamp;
+    readonly sessionCount: SessionCount;
+    readonly new: true;
+}

package/dist/domain/deployments/session-domain.js

@@ -0,0 +1 @@
+import{Branded as t}from"@salsita-ai/common/utils";export const BucketTimestamp=e=>{let o=new Date(e);return o.setMinutes(0,0,0),t(o)};export const SessionCount=e=>{if(e<0)throw Error("Session count cannot be negative");return t(e)};

package/dist/domain/feedback/feedback-domain.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { Branded, type ValueOf } from '@salsita-ai/common/utils';
+/**
+ * Identifies one piece of feedback: a message an SDK builder, or a coding agent working in their project, sent to
+ * the Phoenix team from Studio or the phoenix CLI.
+ */
+export type FeedbackId = Branded<'FeedbackId', string>;
+export declare const FeedbackId: (id: string) => FeedbackId;
+declare const feedbackTypes: {
+    readonly Bug: 'bug';
+    readonly Idea: 'idea';
+    readonly Other: 'other';
+};
+/**
+ * What the sender says the feedback is about: something that is broken, something that is missing or could be
+ * better, or anything else. The sender picks it; the server never infers it.
+ */
+export type FeedbackType = ValueOf<typeof feedbackTypes>;
+export declare const FeedbackTypeSchema: z.ZodNativeEnum<{
+    readonly Bug: 'bug';
+    readonly Idea: 'idea';
+    readonly Other: 'other';
+}>;
+export declare const FeedbackType: ((value: string) => FeedbackType) & {
+    readonly Bug: 'bug';
+    readonly Idea: 'idea';
+    readonly Other: 'other';
+};
+declare const feedbackSources: {
+    readonly Studio: 'studio';
+    readonly Cli: 'cli';
+};
+/**
+ * Where feedback was sent from. Studio feedback comes from a signed-in user's browser session; CLI feedback comes
+ * from `phoenix feedback`, authenticated with an API token, and may be written by a coding agent.
+ */
+export type FeedbackSource = ValueOf<typeof feedbackSources>;
+export declare const FeedbackSourceSchema: z.ZodNativeEnum<{
+    readonly Studio: 'studio';
+    readonly Cli: 'cli';
+}>;
+export declare const FeedbackSource: ((value: string) => FeedbackSource) & {
+    readonly Studio: 'studio';
+    readonly Cli: 'cli';
+};
+/**
+ * Longest feedback message the server stores. Studio and the CLI check it before sending, so a sender learns about
+ * the limit without a round trip.
+ */
+export declare const FEEDBACK_MESSAGE_MAX_LENGTH = 5000;
+/**
+ * Longest contact detail a sender may leave with CLI feedback when they want a reply.
+ */
+export declare const FEEDBACK_CONTACT_MAX_LENGTH = 200;
+export {};

package/dist/domain/feedback/feedback-domain.js

@@ -0,0 +1 @@
+import{validate as e}from"uuid";import{z as t}from"zod";import{Branded as o}from"@salsita-ai/common/utils";export const FeedbackId=t=>{if(!e(t))throw Error(`Invalid feedback id: ${t}. It must be a valid UUID.`);return o(t)};let r={Bug:"bug",Idea:"idea",Other:"other"};export const FeedbackTypeSchema=t.nativeEnum(r);export const FeedbackType=Object.assign(e=>{let t=FeedbackTypeSchema.safeParse(e);if(!t.success)throw Error(`Invalid feedback type: ${e}. It must be one of ${Object.values(r).join(", ")}.`);return t.data},r);let a={Studio:"studio",Cli:"cli"};export const FeedbackSourceSchema=t.nativeEnum(a);export const FeedbackSource=Object.assign(e=>{let t=FeedbackSourceSchema.safeParse(e);if(!t.success)throw Error(`Invalid feedback source: ${e}. It must be one of ${Object.values(a).join(", ")}.`);return t.data},a);export const FEEDBACK_MESSAGE_MAX_LENGTH=5e3;export const FEEDBACK_CONTACT_MAX_LENGTH=200;

package/dist/domain/feedback/index.d.ts

@@ -0,0 +1 @@
+export { FEEDBACK_CONTACT_MAX_LENGTH, FEEDBACK_MESSAGE_MAX_LENGTH, FeedbackId, FeedbackSource, FeedbackSourceSchema, FeedbackType, FeedbackTypeSchema, } from './feedback-domain.js';

package/dist/domain/feedback/index.js

@@ -0,0 +1 @@
+export{FEEDBACK_CONTACT_MAX_LENGTH,FEEDBACK_MESSAGE_MAX_LENGTH,FeedbackId,FeedbackSource,FeedbackSourceSchema,FeedbackType,FeedbackTypeSchema}from"./feedback-domain.js";

package/dist/domain/index.d.ts

@@ -0,0 +1,3 @@
+export * from './deployments/index.js';
+export * from './feedback/index.js';
+export * from './product-configurations/index.js';

package/dist/domain/index.js

@@ -0,0 +1 @@
+export*from"./deployments/index.js";export*from"./feedback/index.js";export*from"./product-configurations/index.js";

package/dist/domain/product-configurations/configurations-domain.d.ts

@@ -0,0 +1,113 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { AccessLevel } from '../../api/access-level.js';
+import type { ApplicationType, ConfigurationSchemaId, EnvironmentId } from '../deployments/index.js';
+export type ConfigurationId = Branded<'ConfigurationId', string>;
+export declare const ConfigurationId: (id: string) => ConfigurationId;
+export type ConfigurationRootEntityType = Branded<'ConfigurationRootEntityType', string>;
+export declare const ConfigurationRootEntityType: (entityType: string) => ConfigurationRootEntityType;
+export type RevisionId = Branded<'RevisionId', string>;
+export declare const RevisionId: (id: string) => RevisionId;
+export type FinalizationUuid = Branded<'FinalizationUuid', string>;
+export declare const FinalizationUuid: (id: string) => FinalizationUuid;
+export type PublishedDataRevisionId = Branded<'PublishedDataRevisionId', string>;
+export declare const PublishedDataRevisionId: (uuid: string) => PublishedDataRevisionId;
+export type PublishedDataRevisionUploadPath = Branded<'PublishedDataRevisionUploadPath', string>;
+export declare const PublishedDataRevisionUploadPath: (path: string) => PublishedDataRevisionUploadPath;
+export type PublishedDataRevisionVersion = Branded<'PublishedDataRevisionVersion', number>;
+export declare const PublishedDataRevisionVersion: (version: number) => PublishedDataRevisionVersion;
+export type PublishedDataChunkId = Branded<'PublishedDataChunkId', string>;
+export declare const PublishedDataChunkId: (uuid: string) => PublishedDataChunkId;
+export type ChunkScope = Branded<'ChunkScope', string>;
+export declare const ChunkScope: (scope: string) => ChunkScope;
+export type ChunkKey = Branded<'ChunkKey', string>;
+export declare const ChunkKey: (key: string) => ChunkKey;
+export interface PublishedDataChunk {
+    readonly id: PublishedDataChunkId;
+    readonly publishedRevisionId: PublishedDataRevisionId;
+    readonly key: ChunkKey;
+    readonly scope: ChunkScope;
+    readonly uploadPath: string;
+    readonly s3Key: string;
+}
+export type FinalizationJobId = Branded<'FinalizationJobId', string>;
+export declare const FinalizationJobId: (id: string) => FinalizationJobId;
+export type ShareId = Branded<'ShareId', string>;
+export declare const ShareId: (uuid: string) => ShareId;
+export interface Entity extends Record<string, unknown> {
+    id: string;
+    type: string;
+}
+export interface NewRevision {
+    data: Entity[];
+    rootEntityType: ConfigurationRootEntityType;
+    configurationSchemaId: ConfigurationSchemaId;
+}
+export interface Revision {
+    id: RevisionId;
+    rootEntityType: ConfigurationRootEntityType;
+    data: Entity[];
+    createdAt: Date;
+    configurationId: ConfigurationId;
+    configurationSchemaId: ConfigurationSchemaId;
+}
+export declare const PublishedDataRevisionKind: {
+    readonly Regular: 'regular';
+    readonly Chunked: 'chunked';
+};
+export type PublishedDataRevisionKind = (typeof PublishedDataRevisionKind)[keyof typeof PublishedDataRevisionKind];
+export interface PublishedDataRevision {
+    readonly kind: typeof PublishedDataRevisionKind.Regular;
+    readonly id: PublishedDataRevisionId;
+    readonly finalizationUuid: FinalizationUuid;
+    readonly uploadPath: PublishedDataRevisionUploadPath;
+    readonly version: PublishedDataRevisionVersion;
+    readonly data: unknown;
+}
+export interface ChunkedPublishedDataRevision {
+    readonly kind: typeof PublishedDataRevisionKind.Chunked;
+    readonly id: PublishedDataRevisionId;
+    readonly finalizationUuid: FinalizationUuid;
+    readonly publishedDataHash: string;
+}
+export type AnyPublishedDataRevision = PublishedDataRevision | ChunkedPublishedDataRevision;
+export interface NewConfiguration {
+    id: null;
+    environmentId: EnvironmentId;
+    type: ApplicationType;
+    revisions: NewRevision[];
+}
+export interface Configuration {
+    id: ConfigurationId;
+    environmentId: EnvironmentId;
+    type: ApplicationType;
+    revisions: Revision[];
+}
+export interface NewFinalization {
+    uuid: FinalizationUuid;
+    revisionId: RevisionId;
+    formData: Record<string, unknown> | null;
+    jobId: FinalizationJobId;
+}
+export interface Finalization {
+    uuid: FinalizationUuid;
+    createdAt: Date;
+    revisionId: RevisionId;
+    formData: Record<string, unknown> | null;
+    jobId: FinalizationJobId;
+}
+export interface NewShare {
+    configurationId: ConfigurationId;
+    revisionId: RevisionId | null;
+    accessLevel: AccessLevel;
+    expiration: number | null;
+    link: string;
+}
+export interface Share {
+    id: ShareId;
+    configurationId: ConfigurationId;
+    revisionId: RevisionId | null;
+    accessLevel: AccessLevel;
+    createdAt: Date;
+    expiredAt: Date | null;
+    link: string;
+}

package/dist/domain/product-configurations/configurations-domain.js

@@ -0,0 +1 @@
+import{validate as t}from"uuid";import{Branded as i}from"@salsita-ai/common/utils";export const ConfigurationId=r=>{if(!t(r))throw Error(`Invalid configuration id: ${r}. It must be a valid UUID.`);return i(r)};export const ConfigurationRootEntityType=t=>i(t);export const RevisionId=r=>{if(!t(r))throw Error(`Invalid revision id: ${r}. It must be a valid UUID.`);return i(r)};export const FinalizationUuid=r=>{if(!t(r))throw Error(`Invalid finalization id: ${r}. It must be a valid UUID.`);return i(r)};export const PublishedDataRevisionId=r=>{if(!t(r))throw Error(`Invalid published data revision id: ${r}. It must be a valid UUID.`);return i(r)};export const PublishedDataRevisionUploadPath=t=>i(t);export const PublishedDataRevisionVersion=t=>i(t);export const PublishedDataChunkId=r=>{if(!t(r))throw Error(`Invalid published data chunk id: ${r}. It must be a valid UUID.`);return i(r)};export const ChunkScope=t=>i(t);let r=/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;export const ChunkKey=t=>{if(!r.test(t))throw Error(`Invalid chunk key '${t}'. Must be lowercase, start with a letter, and contain only letters, numbers, and hyphens.`);return i(t)};export const FinalizationJobId=t=>i(t);export const ShareId=r=>{if(!t(r))throw Error(`Invalid share id: ${r}. It must be a valid UUID.`);return i(r)};export const PublishedDataRevisionKind={Regular:"regular",Chunked:"chunked"};

package/dist/domain/product-configurations/index.d.ts

@@ -0,0 +1 @@
+export { ConfigurationId, ConfigurationRootEntityType, RevisionId, type Revision, type NewRevision, PublishedDataRevisionKind, type PublishedDataRevision, type ChunkedPublishedDataRevision, type AnyPublishedDataRevision, type Configuration, type NewConfiguration, type Entity, FinalizationUuid, type Finalization, type NewFinalization, FinalizationJobId, PublishedDataRevisionId, PublishedDataRevisionUploadPath, PublishedDataRevisionVersion, PublishedDataChunkId, ChunkScope, ChunkKey, type PublishedDataChunk, type NewShare, type Share, ShareId, } from './configurations-domain.js';

package/dist/domain/product-configurations/index.js

@@ -0,0 +1 @@
+export{ConfigurationId,ConfigurationRootEntityType,RevisionId,PublishedDataRevisionKind,FinalizationUuid,FinalizationJobId,PublishedDataRevisionId,PublishedDataRevisionUploadPath,PublishedDataRevisionVersion,PublishedDataChunkId,ChunkScope,ChunkKey,ShareId}from"./configurations-domain.js";

package/dist/webhook/core/index.d.ts

@@ -0,0 +1,3 @@
+export { TaskResourceType, FinalizeTaskResource, type ClientGeneratedImageResource, type ExistingImageResource, type LinkResource, type PdfResource, type CsvResource, type GeneratedImageResource, } from './task-resource.js';
+export { TaskType } from './task-type.js';
+export { TemplateResourceType, ImageTemplateResource, LinkTemplateResource, TemplateResource, StoredTemplate, isStoredTemplate, Template, isTemplate, validateTemplate, } from './template.js';

package/dist/webhook/core/index.js

@@ -0,0 +1 @@
+export{TaskResourceType,FinalizeTaskResource}from"./task-resource.js";export{TaskType}from"./task-type.js";export{TemplateResourceType,ImageTemplateResource,LinkTemplateResource,TemplateResource,StoredTemplate,isStoredTemplate,Template,isTemplate,validateTemplate}from"./template.js";

package/dist/webhook/core/task-resource.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import type { ValueOf } from '@salsita-ai/common/utils';
+export declare const TaskResourceType: {
+    readonly Image: 'Image';
+    readonly Pdf: 'Pdf';
+    readonly Csv: 'Csv';
+    readonly ConfigurationLink: 'ConfigurationLink';
+};
+export type TaskResourceType = ValueOf<typeof TaskResourceType>;
+export interface ClientGeneratedImageResource<RESOURCE extends string = string> {
+    type: typeof TaskResourceType.Image;
+    /**
+     * Unique identifier of the resource, validation will check that the given resource exists as part of the overall FinalizeTask definition
+     */
+    name: RESOURCE;
+    /**
+     * If the resource already exists and is not generated as part of the finalize task, set to true and the validation will not check for the resource definition
+     * This may be useful for static third party resources / deployed static files or pre-generated client side images
+     */
+    clientGenerated: true;
+    /**
+     * URL where the resource is stored
+     */
+    s3Key: string;
+}
+export interface ExistingImageResource<RESOURCE extends string = string> {
+    type: typeof TaskResourceType.Image;
+    /**
+     * Unique identifier of the resource, validation will check that the given resource exists as part of the overall FinalizeTask definition
+     */
+    name: RESOURCE;
+    /**
+     * If the resource already exists and is not generated as part of the finalize task, set to true and the validation will not check for the resource definition
+     * This may be useful for static third party resources / deployed static files or pre-generated client side images
+     */
+    exists: true;
+    /**
+     * URL where the resource is stored
+     */
+    url: string;
+}
+export interface LinkResource<RESOURCE extends string = string> {
+    type: typeof TaskResourceType.ConfigurationLink;
+    name: RESOURCE;
+}
+export interface CsvResource<RESOURCE extends string = string> {
+    type: typeof TaskResourceType.Csv;
+    /**
+     * Unique identifier of the resource, validation will check that the given resource exists as part of the overall FinalizeTask definition
+     */
+    name: RESOURCE;
+    /**
+     * S3 key to this resource. CSV resources are uploaded to this key during finalization.
+     */
+    s3Key?: string;
+}
+export interface PdfResource<RESOURCE extends string = string> {
+    type: typeof TaskResourceType.Pdf;
+    /**
+     * Unique identifier of the resource, validation will check that the given resource exists as part of the overall FinalizeTask definition
+     */
+    name: RESOURCE;
+    /**
+     * S3 key to this resource. PDF resources are uploaded to this key during finalization.
+     */
+    s3Key?: string;
+}
+export interface GeneratedImageResource<RESOURCE extends string = string> {
+    type: typeof TaskResourceType.Image;
+    /**
+     * Unique identifier of the resource, validation will check that the given resource exists as part of the overall FinalizeTask definition
+     */
+    name: RESOURCE;
+    /**
+     * URL where the image will be stored
+     */
+    s3Key: string;
+}
+export type FinalizeTaskResource<RESOURCE extends string = string> = LinkResource<RESOURCE> | CsvResource<RESOURCE> | PdfResource<RESOURCE> | GeneratedImageResource<RESOURCE> | ExistingImageResource<RESOURCE> | ClientGeneratedImageResource<RESOURCE>;
+export declare const FinalizeTaskResource: z.ZodType<FinalizeTaskResource>;

package/dist/webhook/core/task-resource.js

@@ -0,0 +1 @@
+import{z as e}from"zod";export const TaskResourceType={Image:"Image",Pdf:"Pdf",Csv:"Csv",ConfigurationLink:"ConfigurationLink"};export const FinalizeTaskResource=e.union([e.object({type:e.literal(TaskResourceType.ConfigurationLink),name:e.string()}),e.object({type:e.union([e.literal(TaskResourceType.Csv),e.literal(TaskResourceType.Pdf)]),name:e.string(),s3Key:e.string().optional()}),e.object({type:e.literal(TaskResourceType.Image),name:e.string(),exists:e.literal(!0),url:e.string()}),e.object({type:e.literal(TaskResourceType.Image),name:e.string(),clientGenerated:e.literal(!0),s3Key:e.string()}),e.object({type:e.literal(TaskResourceType.Image),name:e.string(),s3Key:e.string()})]);

package/dist/webhook/core/task-type.d.ts

@@ -0,0 +1,18 @@
+import { type ValueOf } from '@salsita-ai/common/utils';
+export declare const TaskType: {
+    readonly GenerateConfigurationLink: 'GenerateConfigurationLink';
+    readonly GenerateImages: 'GenerateImages';
+    readonly GeneratePdf: 'GeneratePdf';
+    readonly GenerateStaticPdf: 'GenerateStaticPdf';
+    readonly GenerateCsv: 'GenerateCsv';
+    readonly SendEmail: 'SendEmail';
+    readonly SendStaticEmail: 'SendStaticEmail';
+    readonly SendHttpRequest: 'SendHttpRequest';
+    readonly PublishRevision: 'PublishRevision';
+    readonly PublishRevisionChunks: 'PublishRevisionChunks';
+    readonly PublishRevisionChunksStaged: 'PublishRevisionChunksStaged';
+    readonly CallLambdaBack: 'CallLambdaBack';
+    readonly WooCommerceAddToCart: 'WooCommerceAddToCart';
+    readonly EditGoogleSpreadsheet: 'EditGoogleSpreadsheet';
+};
+export type TaskType = ValueOf<typeof TaskType>;

package/dist/webhook/core/task-type.js

@@ -0,0 +1 @@
+export const TaskType={GenerateConfigurationLink:"GenerateConfigurationLink",GenerateImages:"GenerateImages",GeneratePdf:"GeneratePdf",GenerateStaticPdf:"GenerateStaticPdf",GenerateCsv:"GenerateCsv",SendEmail:"SendEmail",SendStaticEmail:"SendStaticEmail",SendHttpRequest:"SendHttpRequest",PublishRevision:"PublishRevision",PublishRevisionChunks:"PublishRevisionChunks",PublishRevisionChunksStaged:"PublishRevisionChunksStaged",CallLambdaBack:"CallLambdaBack",WooCommerceAddToCart:"WooCommerceAddToCart",EditGoogleSpreadsheet:"EditGoogleSpreadsheet"};

package/dist/webhook/core/template.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { type ValueOf } from '@salsita-ai/common/utils';
+import { type FinalizeTaskResource, TaskResourceType } from './task-resource.js';
+export declare const TemplateResourceType: {
+    readonly Embedded: 'Embedded';
+    readonly Link: 'Link';
+};
+export type TemplateResourceType = ValueOf<typeof TemplateResourceType>;
+export interface ImageTemplateResource {
+    type: typeof TaskResourceType.Image;
+    /**
+     * Unique identifier of the resource, validation will check that the given resource exists as part of the overall FinalizeTask definition
+     */
+    name: string;
+    /**
+     * The type of the resource, can be either embedded or attachment.
+     *
+     * Embedded attachments will be converted to base64 string and can be included in the template as a data url.
+     *
+     * Link attachments will be included as a link to the attachment (This makes sense only for external resources or Templates used for PDF generation as generated images can be shared only via signed links and would expire in a while).
+     */
+    embeddingType: TemplateResourceType;
+}
+export declare const ImageTemplateResource: z.ZodType<ImageTemplateResource>;
+export interface LinkTemplateResource {
+    type: typeof TaskResourceType.ConfigurationLink;
+    /**
+     * Unique identifier of the resource, validation will check that the given resource exists as part of the overall FinalizeTask definition
+     */
+    name: string;
+}
+export declare const LinkTemplateResource: z.ZodType<LinkTemplateResource>;
+export type TemplateResource = ImageTemplateResource | LinkTemplateResource;
+export declare const TemplateResource: z.ZodType<TemplateResource>;
+/**
+ * Template that is stored and can be referenced by it's unique name. This template will be retrieved and compiled when used in the finalization task.
+ */
+export interface StoredTemplate {
+    /**
+     * Name of the Handlebars template to be used to compile the template
+     */
+    templateName: string;
+    /**
+     * The data to be used to compile the template
+     */
+    data: Record<string, unknown>;
+    /**
+     * The resources to be included in the template from FinalizeTask resources - only images are supported and are included as links to the pdf generation
+     * These will be included into the template's data so they can be used in the template in format "resource-{name}"
+     */
+    includeResources: TemplateResource[];
+}
+export declare const StoredTemplate: z.ZodType<StoredTemplate>;
+export declare function isStoredTemplate(template: StoredTemplate | Template): template is StoredTemplate;
+/**
+ * Inline template that will be compiled with resources will be resolved.
+ */
+export interface Template {
+    template: string;
+    data: Record<string, unknown>;
+    includeResources: TemplateResource[];
+}
+export declare const Template: z.ZodType<Template>;
+export declare function isTemplate(template: StoredTemplate | Template): template is Template;
+export declare const validateTemplate: (template: StoredTemplate | Template, resources: FinalizeTaskResource[]) => void;

package/dist/webhook/core/template.js

@@ -0,0 +1 @@
+import{z as e}from"zod";import{TaskResourceType as t}from"./task-resource.js";export const TemplateResourceType={Embedded:"Embedded",Link:"Link"};export const ImageTemplateResource=e.object({name:e.string(),type:e.literal(t.Image),embeddingType:e.union([e.literal(TemplateResourceType.Embedded),e.literal(TemplateResourceType.Link)])});export const LinkTemplateResource=e.object({name:e.string(),type:e.literal(t.ConfigurationLink)});export const TemplateResource=e.union([ImageTemplateResource,LinkTemplateResource]);export const StoredTemplate=e.object({templateName:e.string(),data:e.record(e.unknown()),includeResources:e.array(TemplateResource)});export function isStoredTemplate(e){return"templateName"in e}export const Template=e.object({template:e.string(),data:e.record(e.unknown()),includeResources:e.array(TemplateResource)});export function isTemplate(e){return"template"in e}export const validateTemplate=(e,o)=>{e.includeResources.forEach(e=>{let r=o.find(t=>t.name===e.name);if(null==r)throw Error(`The provided FinalizeTask configuration is invalid! Resource ${e.name} is not declared in the resources. Provide a resource with the name ${e.name}.`);if(r.type!==t.Image&&r.type!==t.ConfigurationLink)throw Error(`The provided FinalizeTask configuration is invalid! Resource ${e.name} is not an image or configuration link. Only images or configuration links can be provided for TemplateResource.`)})};

package/dist/webhook/empty-xlsx.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Embedded minimal blank `.xlsx` (Office Open XML) workbook. Used by the
+ * Microsoft adapter's `createWorkbook` — `PUT .../content` requires real xlsx
+ * bytes; Graph cannot synthesize a workbook from a 0-byte file.
+ *
+ * Contains: `[Content_Types].xml`, `_rels/.rels`, `xl/workbook.xml`,
+ * `xl/_rels/workbook.xml.rels`, `xl/worksheets/sheet1.xml`, `xl/styles.xml`.
+ * Single empty worksheet named `Sheet1`. ~1.7KB.
+ */
+export declare const EMPTY_XLSX_BYTES: Uint8Array<ArrayBuffer>;

package/dist/webhook/empty-xlsx.js

@@ -0,0 +1 @@
+export const EMPTY_XLSX_BYTES=Uint8Array.from(atob("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"),A=>A.charCodeAt(0));