@hitch42/applet 0.1.1-beta.7 → 0.1.1-beta.8

package/dist/index.js

@@ -1,5 +1,7 @@
 import { i as registerHitchContract, t as uploadFile } from "./upload-DRbVhuDm.js";
-import { n as appletManifestSchema, r as appletSourceDefinitionSchema, t as appletDefinitionSchema } from "./manifest-Bd04cWhu.js";
+import { a as emailTagsSchema, c as listEmailTrackersInputSchema, d as markEmailTrackerSentInputSchema, i as emailTagKeySchema, l as listEmailTrackersOutputSchema, n as createEmailPixelOutputSchema, o as emailTrackerSchema, r as emailContract, s as getEmailTrackerInputSchema, t as createEmailPixelInputSchema } from "./email-DBTVhNB_.js";
+import { n as meSchema, t as meContract } from "./me-BW7Paary.js";
+import { n as appletManifestSchema, r as appletSourceDefinitionSchema, t as appletDefinitionSchema } from "./manifest-Bp87Uz0a.js";
 import { oc } from "@orpc/contract";
 import { z } from "zod";
 //#region src/hitch/contract.ts
@@ -78,34 +80,147 @@ const filesContract = {
 	}).input(fileIdInputSchema).output(getFileOutputSchema)
 };
 //#endregion
-//#region src/hitch/me.ts
-const personSchema = z.object({
+//#region src/hitch/telephony.ts
+const hitchPhoneNumberSchema = z.object({
 	id: z.uuid(),
-	firstName: z.string(),
-	lastName: z.string(),
-	email: z.email()
+	e164: z.string(),
+	label: z.string(),
+	enabled: z.boolean(),
+	canRead: z.boolean(),
+	canSend: z.boolean(),
+	canCall: z.boolean(),
+	voiceEnabled: z.boolean()
+});
+const hitchCallSchema = z.object({
+	id: z.uuid(),
+	numberId: z.uuid(),
+	direction: z.enum(["inbound", "outbound"]),
+	status: z.enum([
+		"starting",
+		"ringing",
+		"active",
+		"ended",
+		"missed",
+		"failed"
+	]),
+	from: z.string(),
+	to: z.string(),
+	userId: z.uuid().nullable(),
+	answeredAt: z.string().nullable(),
+	endedAt: z.string().nullable(),
+	durationSeconds: z.number().nullable(),
+	voicemailSeconds: z.number().nullable(),
+	hangupCause: z.string().nullable(),
+	record: z.boolean(),
+	hasRecording: z.boolean(),
+	transcriptStatus: z.enum([
+		"pending",
+		"done",
+		"failed"
+	]).nullable(),
+	transcript: z.object({ segments: z.array(z.object({
+		side: z.enum(["member", "customer"]),
+		speaker: z.number(),
+		start: z.number(),
+		end: z.number(),
+		text: z.string()
+	})) }).nullable(),
+	createdAt: z.string()
+});
+const hitchMessageSchema = z.object({
+	id: z.uuid(),
+	numberId: z.uuid(),
+	direction: z.enum(["inbound", "outbound"]),
+	status: z.enum([
+		"pending",
+		"unknown",
+		"accepted",
+		"sent",
+		"delivered",
+		"unconfirmed",
+		"failed",
+		"received"
+	]),
+	from: z.string(),
+	to: z.string(),
+	body: z.string().nullable(),
+	redacted: z.boolean(),
+	userId: z.uuid().nullable(),
+	appletId: z.uuid().nullable(),
+	requestId: z.string().nullable(),
+	errorCode: z.string().nullable(),
+	errorDetail: z.string().nullable(),
+	statusAt: z.string().nullable(),
+	createdAt: z.string()
+});
+const listHitchNumbersOutputSchema = z.object({ data: z.array(hitchPhoneNumberSchema) });
+const listHitchMessagesOutputSchema = z.object({
+	data: z.array(hitchMessageSchema),
+	nextCursor: z.string().nullable()
+});
+const listHitchCallsOutputSchema = z.object({
+	data: z.array(hitchCallSchema),
+	nextCursor: z.string().nullable()
 });
-const membershipSchema = z.object({
-	orgId: z.uuid(),
-	code: z.string(),
-	name: z.string(),
-	iconFileId: z.uuid().nullable(),
-	role: z.enum(["member", "owner"]),
-	capabilities: z.array(z.string())
+const idInputSchema = z.object({ id: z.uuid() });
+const listInputFields = {
+	numberId: z.uuid().optional(),
+	userId: z.uuid().optional(),
+	direction: z.enum(["inbound", "outbound"]).optional(),
+	since: z.iso.datetime().optional(),
+	until: z.iso.datetime().optional(),
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(200).optional()
+};
+const listHitchMessagesInputSchema = z.object(listInputFields);
+const listHitchCallsInputSchema = z.object({
+	...listInputFields,
+	status: z.enum([
+		"starting",
+		"ringing",
+		"active",
+		"ended",
+		"missed",
+		"failed"
+	]).optional()
 });
-const meSchema = z.object({
-	person: personSchema,
-	memberships: z.array(membershipSchema),
-	organization: z.object({
-		id: z.uuid(),
-		code: z.string()
-	}).nullable(),
-	multiOrg: z.boolean()
+const sendHitchMessageInputSchema = z.object({
+	numberId: z.uuid(),
+	to: z.string(),
+	body: z.string().min(1).max(1600),
+	requestId: z.string().min(1).max(200).optional()
 });
-const meContract = { get: oc.route({
-	method: "GET",
-	path: "/v1/me"
-}).input(z.void()).output(meSchema) };
+const telephonyContract = {
+	calls: {
+		get: oc.route({
+			method: "GET",
+			path: "/v1/telephony/calls/{id}"
+		}).input(idInputSchema).output(hitchCallSchema),
+		list: oc.route({
+			method: "GET",
+			path: "/v1/telephony/calls"
+		}).input(listHitchCallsInputSchema).output(listHitchCallsOutputSchema)
+	},
+	numbers: { list: oc.route({
+		method: "GET",
+		path: "/v1/telephony/numbers"
+	}).input(z.void()).output(listHitchNumbersOutputSchema) },
+	messages: {
+		get: oc.route({
+			method: "GET",
+			path: "/v1/telephony/messages/{id}"
+		}).input(idInputSchema).output(hitchMessageSchema),
+		list: oc.route({
+			method: "GET",
+			path: "/v1/telephony/messages"
+		}).input(listHitchMessagesInputSchema).output(listHitchMessagesOutputSchema),
+		send: oc.route({
+			method: "POST",
+			path: "/v1/telephony/messages",
+			successStatus: 201
+		}).input(sendHitchMessageInputSchema).output(hitchMessageSchema)
+	}
+};
 //#endregion
 //#region src/hitch/teams.ts
 const teamSchema = z.object({
@@ -133,4 +248,4 @@ const teamsContract = {
 	}).input(teamIdInputSchema).output(teamMembersOutputSchema) }
 };
 //#endregion
-export { appletDefinitionSchema, appletManifestSchema, appletSourceDefinitionSchema, createFileOutputSchema, fileSchema, filesContract, getFileOutputSchema, meContract, meSchema, pruneContract, registerHitchContract, teamMemberSchema, teamSchema, teamsContract, uploadFile };
+export { appletDefinitionSchema, appletManifestSchema, appletSourceDefinitionSchema, createEmailPixelInputSchema, createEmailPixelOutputSchema, createFileOutputSchema, emailContract, emailTagKeySchema, emailTagsSchema, emailTrackerSchema, fileSchema, filesContract, getEmailTrackerInputSchema, getFileOutputSchema, hitchMessageSchema, hitchPhoneNumberSchema, listEmailTrackersInputSchema, listEmailTrackersOutputSchema, listHitchMessagesInputSchema, listHitchMessagesOutputSchema, listHitchNumbersOutputSchema, markEmailTrackerSentInputSchema, meContract, meSchema, pruneContract, registerHitchContract, sendHitchMessageInputSchema, teamMemberSchema, teamSchema, teamsContract, telephonyContract, uploadFile };

package/dist/{init-Wu6XmyVc.js → init-jDEgYIXg.js}

@@ -1,8 +1,8 @@
-import { a as ORG_CODE_PATTERN, i as APPLET_CODE_PATTERN } from "./manifest-Bd04cWhu.js";
-import { c as resolveAuthForOrg, i as readWorkspaceConfig, l as resolveInstanceUrl } from "./workspace-B6lenAS5.js";
-import { n as runGenerate } from "./generate-BIifT6PK.js";
-import { n as loadAppletSourceDefinition } from "./load-config-BknBkdRs.js";
-import { a as writeAppletSupport, n as loadCliManifest, o as writeWorkspaceSupport, t as assertWorkspaceCli } from "./project-C_rtpjp8.js";
+import { a as ORG_CODE_PATTERN, i as APPLET_CODE_PATTERN } from "./manifest-Bp87Uz0a.js";
+import { d as resolveInstanceUrl, i as readWorkspaceConfig, u as resolveAuthForOrg } from "./workspace-XVtM12ZC.js";
+import { n as runGenerate } from "./generate-BxYHdoAQ.js";
+import { n as loadAppletSourceDefinition } from "./load-config-BYSxDVAl.js";
+import { a as writeAppletSupport, n as loadCliManifest, o as writeWorkspaceSupport, t as assertWorkspaceCli } from "./project-CbYPtpPq.js";
 import { access, cp, mkdir, readdir, writeFile } from "node:fs/promises";
 import { relative, resolve } from "node:path";
 import { spawn } from "node:child_process";

package/dist/{load-config-BknBkdRs.js → load-config-BYSxDVAl.js}

@@ -1,5 +1,5 @@
-import { r as appletSourceDefinitionSchema } from "./manifest-Bd04cWhu.js";
-import { t as resolveWorkspaceOrg } from "./workspace-B6lenAS5.js";
+import { r as appletSourceDefinitionSchema } from "./manifest-Bp87Uz0a.js";
+import { t as resolveWorkspaceOrg } from "./workspace-XVtM12ZC.js";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { loadConfigFromFile } from "vite";

package/dist/{login-iT9MRuaw.js → login-C7RKmmTe.js}

@@ -1,4 +1,4 @@
-import { a as loginWithDevice, l as resolveInstanceUrl, o as AuthenticationError, r as findWorkspaceConfig } from "./workspace-B6lenAS5.js";
+import { a as loginWithDevice, d as resolveInstanceUrl, o as AuthenticationError, r as findWorkspaceConfig } from "./workspace-XVtM12ZC.js";
 //#region src/login.ts
 async function runLogin(options) {
 	if (process.env.HITCH_API_KEY !== void 0) throw new AuthenticationError("HITCH_API_KEY is set — unset it to manage stored logins.");

package/dist/{logs-B-qZGXSK.js → logs-DgjgAxj2.js}

@@ -1,6 +1,6 @@
-import { i as APPLET_CODE_PATTERN } from "./manifest-Bd04cWhu.js";
-import { i as readWorkspaceConfig, n as fetchWithOrgAuth, t as resolveWorkspaceOrg } from "./workspace-B6lenAS5.js";
-import { t as loadAppletConfig } from "./load-config-BknBkdRs.js";
+import { i as APPLET_CODE_PATTERN } from "./manifest-Bp87Uz0a.js";
+import { i as readWorkspaceConfig, n as fetchWithOrgAuth, t as resolveWorkspaceOrg } from "./workspace-XVtM12ZC.js";
+import { t as loadAppletConfig } from "./load-config-BYSxDVAl.js";
 import { z } from "zod";
 //#region src/logs.ts
 const LOG_LEVELS = [

package/dist/{manifest-Bd04cWhu.js → manifest-Bp87Uz0a.js}

@@ -64,6 +64,7 @@ const appletManifestShape = {
 	name: nameSchema,
 	code: codeSchema,
 	requiresChangeset: z.uuid().optional(),
+	telephony: z.strictObject({ events: z.array(z.literal("message.received")).min(1).refine((events) => new Set(events).size === events.length).readonly() }).optional(),
 	schedules: appletManifestSchedulesSchema.optional(),
 	variables: appletManifestVariablesSchema.optional(),
 	objects: appletManifestObjectsSchema
@@ -96,6 +97,7 @@ const appletDefinitionSchema = z.strictObject({
 	name: appletManifestShape.name,
 	code: appletManifestShape.code,
 	requiresChangeset: appletManifestShape.requiresChangeset,
+	telephony: appletManifestShape.telephony,
 	schedules: appletManifestShape.schedules,
 	variables: appletManifestShape.variables,
 	objects: appletManifestShape.objects
@@ -164,6 +166,7 @@ const appletSourceDefinitionSchema = z.strictObject({
 	name: appletManifestShape.name,
 	code: appletManifestShape.code,
 	requiresChangeset: appletManifestShape.requiresChangeset,
+	telephony: appletManifestShape.telephony,
 	schedules: appletManifestShape.schedules,
 	variables: appletManifestShape.variables,
 	objects: appletManifestShape.objects,

package/dist/{manifest-C489nYUy.d.ts → manifest-DD_SGkS6.d.ts}

@@ -34,6 +34,9 @@ interface AppletManifest {
   code: string;
   /** This code needs the schema as of this changeset. */
   requiresChangeset?: string;
+  telephony?: {
+    events: readonly "message.received"[];
+  };
   schedules?: readonly {
     code: string;
     name: string;

package/dist/me-BW7Paary.js

@@ -0,0 +1,32 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/me.ts
+const personSchema = z.object({
+	id: z.uuid(),
+	firstName: z.string(),
+	lastName: z.string(),
+	email: z.email()
+});
+const membershipSchema = z.object({
+	orgId: z.uuid(),
+	code: z.string(),
+	name: z.string(),
+	iconFileId: z.uuid().nullable(),
+	role: z.enum(["member", "owner"]),
+	capabilities: z.array(z.string())
+});
+const meSchema = z.object({
+	person: personSchema,
+	memberships: z.array(membershipSchema),
+	organization: z.object({
+		id: z.uuid(),
+		code: z.string()
+	}).nullable(),
+	multiOrg: z.boolean()
+});
+const meContract = { get: oc.route({
+	method: "GET",
+	path: "/v1/me"
+}).input(z.void()).output(meSchema) };
+//#endregion
+export { meSchema as n, meContract as t };

package/dist/{project-C_rtpjp8.js → project-CbYPtpPq.js}

@@ -1,5 +1,5 @@
-import { i as readWorkspaceConfig } from "./workspace-B6lenAS5.js";
-import { n as loadAppletSourceDefinition } from "./load-config-BknBkdRs.js";
+import { i as readWorkspaceConfig } from "./workspace-XVtM12ZC.js";
+import { n as loadAppletSourceDefinition } from "./load-config-BYSxDVAl.js";
 import { z } from "zod";
 import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
@@ -131,7 +131,8 @@ const GITIGNORE_END = "# END Hitch generated files";
 const SKILLS = [
 	"hitch-applets",
 	"hitch-cli",
-	"hitch-data"
+	"hitch-data",
+	"hitch-theory"
 ];
 const GITIGNORE = `${GITIGNORE_START}
 ${SKILLS.map((skill) => `/.agents/skills/${skill}/`).join("\n")}
@@ -179,7 +180,7 @@ async function writeWorkspaceSupport(root, config, cli) {
 	const agents = await readFile(new URL("../scaffold/AGENTS.md", import.meta.url), "utf8");
 	await Promise.all([
 		mkdir(resolve(root, ".agents/skills"), { recursive: true }),
-		mkdir(resolve(root, ".github/workflows"), { recursive: true }),
+		config.githubWorkflow === false ? void 0 : mkdir(resolve(root, ".github/workflows"), { recursive: true }),
 		...SKILLS.map((skill) => rm(resolve(root, ".agents/skills", skill), {
 			force: true,
 			recursive: true
@@ -189,7 +190,7 @@ async function writeWorkspaceSupport(root, config, cli) {
 		...SKILLS.map((skill) => cp(new URL(`../scaffold/.agents/skills/${skill}`, import.meta.url), resolve(root, ".agents/skills", skill), { recursive: true })),
 		writeFile(resolve(root, "package.json"), `${JSON.stringify(workspacePackage(config.org), null, 2)}\n`),
 		writeFile(resolve(root, "pnpm-workspace.yaml"), workspaceFile(resolvedCli)),
-		existsSync(deployWorkflowTarget) ? void 0 : cp(new URL("../scaffold/.github/workflows/hitch.yml", import.meta.url), deployWorkflowTarget),
+		config.githubWorkflow === false || existsSync(deployWorkflowTarget) ? void 0 : cp(new URL("../scaffold/.github/workflows/hitch.yml", import.meta.url), deployWorkflowTarget),
 		writeFile(resolve(root, ".node-version"), "24\n"),
 		writeGitignore(root),
 		writeFile(resolve(root, "AGENTS.md"), agents)

package/dist/prompt-ChS-grYO.js

@@ -0,0 +1,29 @@
+import { Writable } from "node:stream";
+import { createInterface } from "node:readline";
+//#region src/prompt.ts
+function question(prompt, hidden = false) {
+	return new Promise((resolveAnswer, rejectAnswer) => {
+		let muted = false;
+		const output = hidden ? new Writable({ write(chunk, encoding, callback) {
+			if (!muted) process.stdout.write(chunk, encoding);
+			callback();
+		} }) : process.stdout;
+		const readline = createInterface({
+			input: process.stdin,
+			output,
+			terminal: true
+		});
+		readline.once("error", rejectAnswer);
+		if (hidden) {
+			process.stdout.write(prompt);
+			muted = true;
+		}
+		readline.question(hidden ? "" : prompt, (answer) => {
+			readline.close();
+			if (hidden) process.stdout.write("\n");
+			resolveAnswer(answer);
+		});
+	});
+}
+//#endregion
+export { question as t };

package/dist/schedules-dhU1yyFr.js

@@ -0,0 +1,42 @@
+import { t as loadAppletConfig } from "./load-config-BYSxDVAl.js";
+import { t as question } from "./prompt-ChS-grYO.js";
+import { RPCLink } from "@orpc/client/fetch";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+//#region src/schedules.ts
+async function runSchedule(options) {
+	const manifest = await loadAppletConfig(process.cwd());
+	const schedules = manifest.schedules ?? [];
+	if (schedules.length === 0) throw new Error("This applet has no schedules.");
+	const schedule = schedules.find(({ code }) => code === options.code);
+	if (schedule === void 0) throw new Error(`Unknown schedule "${options.code}". Valid codes: ${schedules.map(({ code }) => code).join(", ")}.`);
+	const unavailable = "The dev server is not running. Start it with pnpm dev.";
+	let url;
+	try {
+		const file = JSON.parse(await readFile(resolve(process.cwd(), ".hitch/dev-server.json"), "utf8"));
+		if (file === null || typeof file !== "object" || !("url" in file) || typeof file.url !== "string" || !("pid" in file) || typeof file.pid !== "number" || !Number.isInteger(file.pid) || file.pid < 1) throw new Error(unavailable);
+		try {
+			process.kill(file.pid, 0);
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EPERM")) throw error;
+		}
+		url = new URL(file.url).origin;
+	} catch {
+		throw new Error(unavailable);
+	}
+	if (options.yes !== true) {
+		if (process.stdin.isTTY !== true) throw new Error("Pass --yes to run a schedule without a terminal.");
+		const answer = await question(`Run schedule "${options.code}" (${schedule.path}) now? It runs your local code as you in production org "${manifest.org}". [y/N] `);
+		if (!["y", "yes"].includes(answer.trim().toLowerCase())) throw new Error("Schedule run cancelled.");
+	}
+	await new RPCLink({
+		url: `${url}/${manifest.code}/api`,
+		fetch
+	}).call(schedule.path.split("/").filter(Boolean), {}, { context: {} }).catch((error) => {
+		if (error instanceof TypeError && error.message === "fetch failed") throw new Error(unavailable);
+		throw error;
+	});
+	console.log(`Schedule "${options.code}" finished.`);
+}
+//#endregion
+export { runSchedule };

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import { a as createWorkflow, i as WorkflowStep, n as WorkflowDefinition, r as WorkflowDuration } from "./workflow-DurM6Fwx.js";
-import { _ as RegisteredWorkflows, f as RegisteredContract, g as RegisteredVariables, p as RegisteredManifest } from "./manifest-C489nYUy.js";
-import { t as NarrowContract } from "./contract-DB9QQhD9.js";
+import { _ as RegisteredWorkflows, f as RegisteredContract, g as RegisteredVariables, p as RegisteredManifest } from "./manifest-DD_SGkS6.js";
+import { t as NarrowContract } from "./contract-rP_eV9PK.js";
 import { t as WithBatchRecorder } from "./batch-Qa4B4-Yp.js";
 import { o as WithFilesUpload } from "./upload-YbRKEqR6.js";
 import { ContractRouterClient } from "@orpc/contract";

package/dist/telephony-protocol-DRgiYjqQ.d.ts

@@ -0,0 +1,74 @@
+import { ContractProcedure, Meta } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/email.d.ts
+type EmailTags = Record<string, string>;
+type CreateEmailPixelInput = {
+  tags?: EmailTags;
+};
+type CreateEmailPixelOutput = {
+  id: string;
+  url: string;
+};
+type GetEmailTrackerInput = {
+  id: string;
+};
+type MarkEmailTrackerSentInput = {
+  id: string;
+  sentAt?: string;
+};
+type EmailTracker = {
+  id: string;
+  url: string;
+  tags: EmailTags;
+  createdAt: string;
+  sentAt: string | null;
+  firstHitAt: string | null;
+  lastHitAt: string | null;
+};
+type ListEmailTrackersInput = {
+  filter?: EmailTags;
+  sentAt?: {
+    $gte?: string;
+    $lt?: string;
+  };
+  cursor?: string;
+  limit?: number;
+};
+type ListEmailTrackersOutput = {
+  trackers: EmailTracker[];
+  nextCursor: string | null;
+};
+declare const emailTagKeySchema: z.ZodType<string>;
+declare const emailTagsSchema: z.ZodType<EmailTags>;
+declare const createEmailPixelInputSchema: z.ZodType<CreateEmailPixelInput>;
+declare const createEmailPixelOutputSchema: z.ZodType<CreateEmailPixelOutput>;
+declare const getEmailTrackerInputSchema: z.ZodType<GetEmailTrackerInput>;
+declare const markEmailTrackerSentInputSchema: z.ZodType<MarkEmailTrackerSentInput>;
+declare const markEmailTrackerSentBodySchema: z.ZodType<{
+  sentAt?: string;
+}>;
+declare const emailTrackerSchema: z.ZodType<EmailTracker>;
+declare const listEmailTrackersInputSchema: z.ZodType<ListEmailTrackersInput>;
+declare const listEmailTrackersOutputSchema: z.ZodType<ListEmailTrackersOutput>;
+type EmailContract = {
+  tracking: {
+    createPixel: ContractProcedure<z.ZodType<CreateEmailPixelInput | undefined>, z.ZodType<CreateEmailPixelOutput>, Record<never, never>, Meta>;
+    markSent: ContractProcedure<z.ZodType<MarkEmailTrackerSentInput>, z.ZodType<EmailTracker>, Record<never, never>, Meta>;
+    get: ContractProcedure<z.ZodType<GetEmailTrackerInput>, z.ZodType<EmailTracker>, Record<never, never>, Meta>;
+    list: ContractProcedure<z.ZodType<ListEmailTrackersInput | undefined>, z.ZodType<ListEmailTrackersOutput>, Record<never, never>, Meta>;
+  };
+};
+declare function emailContract(appletCode: string): EmailContract;
+//#endregion
+//#region src/server/telephony-protocol.d.ts
+/** Handle events at least once and without order. Use eventId for idempotency.
+ * Read the message with hitch.telephony.messages.get({ id: messageId }). */
+type TelephonyMessageReceivedEvent = {
+  eventId: string;
+  type: "message.received";
+  messageId: string;
+  numberId: string;
+  occurredAt: string;
+};
+//#endregion
+export { createEmailPixelOutputSchema as a, emailTagsSchema as c, listEmailTrackersInputSchema as d, listEmailTrackersOutputSchema as f, createEmailPixelInputSchema as i, emailTrackerSchema as l, markEmailTrackerSentInputSchema as m, EmailTracker as n, emailContract as o, markEmailTrackerSentBodySchema as p, ListEmailTrackersOutput as r, emailTagKeySchema as s, TelephonyMessageReceivedEvent as t, getEmailTrackerInputSchema as u };

package/dist/telephony.d.ts

@@ -0,0 +1,77 @@
+//#region src/telephony/phone.d.ts
+type PhoneState = {
+  status: "off" | "connecting" | "ready" | "error";
+  error: string | null;
+  active: null | {
+    callId: string;
+    to: string;
+    from: string;
+    state: "connecting" | "ringing" | "active" | "held" | "ended";
+    muted: boolean;
+    startedAt: number;
+    recording: boolean;
+  };
+};
+type CallInput = {
+  numberId: string;
+  to: string;
+};
+type Listener = () => void;
+type ActiveControls = {
+  hangup: () => Promise<void>;
+  mute: () => void;
+  unmute: () => void;
+  hold: () => Promise<unknown>;
+  unhold: () => Promise<unknown>;
+  dtmf: (digit: string) => void;
+};
+declare class Phone {
+  state: PhoneState;
+  private readonly listeners;
+  private readonly api;
+  private client;
+  private currentCall;
+  private connectPromise;
+  private releaseLock;
+  private lockAbortController;
+  private channel;
+  private ownsPhone;
+  private connectResolve;
+  private readonly pendingCommands;
+  private pollTimer;
+  private stopRecording;
+  private recordingPromise;
+  private audio;
+  private firstLogin;
+  private callStarting;
+  constructor(options?: {
+    baseUrl?: string;
+  });
+  subscribe: (listener: Listener) => (() => void);
+  getSnapshot: () => PhoneState;
+  private update;
+  get active(): ActiveControls | null;
+  connect: () => Promise<void>;
+  private connectInternal;
+  private connectOwned;
+  disconnect: () => void;
+  private beforeUnload;
+  call: ({ numberId, to }: CallInput) => Promise<void>;
+  private sendCommand;
+  private onChannelMessage;
+  private runCommand;
+  private pollCall;
+  private onCallUpdate;
+}
+declare const createPhone: (options?: {
+  baseUrl?: string;
+}) => Phone;
+//#endregion
+//#region src/telephony/use-phone.d.ts
+declare const usePhone: () => {
+  state: PhoneState;
+  call: Phone["call"];
+  active: Phone["active"];
+};
+//#endregion
+export { type Phone, type PhoneState, createPhone, usePhone };