@blazingagents/sdk 0.34.0 → 0.36.0

package/dist/contracts/entities/sessions.js

@@ -4,7 +4,7 @@ import { agentIdSchema, sessionIdSchema } from "../ids.js";
 import { toolExecutionReferenceSchema } from "./agent-approval.js";
 import { agentConfigSchema, agentResponseSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
-import { chatFunctionDefinitionsSchema } from "./chat.js";
+import { chatRequestBodySchema } from "./chat.js";
 /**
  * `GET /v1/agents/{agentId}/sessions` list item. `agentId`/`tenantId` never
  * leak to the wire; `userId`/`metadata` come from the first successful Turn.
@@ -106,7 +106,7 @@ export const toolApprovalStateSchema = z
     decidedAt: z.iso.datetime({ offset: true }).nullable().optional(),
     approvalId: z.string().min(1),
     decision: z.enum(["pending", "approved", "denied"]),
-    input: z.json(),
+    input: z.json().meta({ type: "object" }),
     reason: z.string().nullable(),
     toolCallId: z.string().min(1),
     toolName: z.string().min(1),
@@ -130,8 +130,9 @@ export const continueToolApprovalsBodySchema = z
         .array(toolApprovalDecisionSchema)
         .min(1)
         .refine((decisions) => new Set(decisions.map((decision) => decision.approvalId)).size ===
-        decisions.length, { message: "Approval IDs must be distinct." }),
-    functions: chatFunctionDefinitionsSchema.optional(),
+        decisions.length, { message: "Approval IDs must be distinct." })
+        .describe("One decision for every approval in the current round."),
+    functions: chatRequestBodySchema.shape.functions,
 })
     .strict();
 /**

package/dist/contracts/entities/skills.js

@@ -55,8 +55,10 @@ export const skillDetailSchema = skillSchema
 export const skillsListResponseSchema = paginatedResponseSchema(skillSchema);
 export const createSkillBodySchema = z
     .object({
-    path: z.literal("SKILL.md"),
-    content: z.string(),
+    path: z.literal("SKILL.md").describe("Always `SKILL.md`."),
+    content: z
+        .string()
+        .describe("The `SKILL.md` document. It must start with YAML frontmatter that sets `name` and `description`."),
 })
     .strict();
 export const skillArchiveTypeSchema = z.enum(["zip", "tar", "tar.gz"]);
@@ -68,7 +70,8 @@ export const copySkillBodySchema = z
         .max(MAX_SKILL_COPY_DESTINATIONS)
         .refine(hasUniqueValues, {
         message: "Destination Agent ids must be unique.",
-    }),
+    })
+        .describe("IDs of the agents to copy the skill to, each listed once. Send 1 to 30."),
 })
     .strict();
 const skillCopyCreatedResultSchema = z

package/dist/contracts/entities/tasks.d.ts

@@ -41,13 +41,8 @@ export declare const taskScheduleInputSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         timezone: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>], "kind">;
-/**
- * `POST /v1/tasks` — schedule present = scheduled task; absent = on-demand.
- * `submit: true` enqueues a run immediately. An optional `idempotencyKey`
- * makes retries return the original Task and initial run id. Without a key,
- * each call creates a new Task. Run creation has its own idempotency key.
- */
 export declare const createTaskBodySchema: z.ZodObject<{
+    idempotencyKey: z.ZodOptional<z.ZodString>;
     agentId: z.ZodString;
     name: z.ZodString;
     prompt: z.ZodString;
@@ -71,7 +66,6 @@ export declare const createTaskBodySchema: z.ZodObject<{
     }, z.core.$strict>], "kind">>>;
     enabled: z.ZodDefault<z.ZodBoolean>;
     submit: z.ZodDefault<z.ZodBoolean>;
-    idempotencyKey: z.ZodOptional<z.ZodString>;
     userId: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
@@ -601,6 +595,9 @@ export declare const taskRunMessagesResponseSchema: z.ZodObject<{
         succeeded: "succeeded";
     }>;
 }, z.core.$strip>;
+export type TaskListItem = z.infer<typeof taskListItemSchema>;
+export type TaskRunStatus = z.infer<typeof taskRunStatusSchema>;
+export type TaskScheduleInput = z.infer<typeof taskScheduleInputSchema>;
 export type TasksListResponse = z.infer<typeof tasksListResponseSchema>;
 export type TaskResponse = z.infer<typeof taskResponseSchema>;
 export type TaskRunResponse = z.infer<typeof taskRunResponseSchema>;

package/dist/contracts/entities/tasks.js

@@ -110,27 +110,52 @@ const taskPromptSchema = z.string().trim().min(1).max(MAX_TASK_PROMPT_LENGTH);
  * makes retries return the original Task and initial run id. Without a key,
  * each call creates a new Task. Run creation has its own idempotency key.
  */
+const taskFieldDescriptions = {
+    agentId: "ID of the agent that runs the task. It cannot change later.",
+    name: "Display name, 1 to 80 characters.",
+    prompt: "The prompt the agent receives on every run, 1 to 6,000 characters.",
+    schedule: "When the task runs by itself: `once` at a time, every `everyMs` milliseconds (at least 60,000) for `interval`, or a five-field cron expression in an IANA timezone for `cron`. `null` means the task runs only when you start it.",
+    enabled: "Whether the schedule fires. A disabled task can still be started on demand.",
+    submit: "Start a run as soon as the task is created.",
+    userId: "Your end user's ID, used for attribution. An empty string means a tenant-level task. It cannot change after creation.",
+    metadata: "Your own key-value data, returned unchanged and copied to each run.",
+};
 export const createTaskBodySchema = z
     .object({
-    agentId: agentIdSchema,
-    name: taskNameSchema,
-    prompt: taskPromptSchema,
-    schedule: taskScheduleInputSchema.nullable().default(null),
-    enabled: z.boolean().default(true),
-    submit: z.boolean().default(false),
-    idempotencyKey: z.string().trim().min(1).optional(),
-    userId: userIdSchema.default(""),
-    metadata: metadataSchema.default({}),
+    idempotencyKey: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Retry the same creation with this key to return the current task and its original initial run. Changed requests or deleted tasks return a conflict."),
+    agentId: agentIdSchema.describe(taskFieldDescriptions.agentId),
+    name: taskNameSchema.describe(taskFieldDescriptions.name),
+    prompt: taskPromptSchema.describe(taskFieldDescriptions.prompt),
+    schedule: taskScheduleInputSchema
+        .nullable()
+        .default(null)
+        .describe(taskFieldDescriptions.schedule),
+    enabled: z.boolean().default(true).describe(taskFieldDescriptions.enabled),
+    submit: z.boolean().default(false).describe(taskFieldDescriptions.submit),
+    userId: userIdSchema.default("").describe(taskFieldDescriptions.userId),
+    metadata: metadataSchema
+        .default({})
+        .describe(taskFieldDescriptions.metadata),
 })
     .strict();
 // `PATCH /v1/tasks/{taskId}` — `agentId` and `userId` are immutable.
 export const updateTaskBodySchema = z
     .object({
-    name: taskNameSchema.optional(),
-    prompt: taskPromptSchema.optional(),
-    schedule: taskScheduleInputSchema.nullable().optional(),
-    enabled: z.boolean().optional(),
-    metadata: metadataSchema.optional(),
+    name: taskNameSchema.optional().describe(taskFieldDescriptions.name),
+    prompt: taskPromptSchema.optional().describe(taskFieldDescriptions.prompt),
+    schedule: taskScheduleInputSchema
+        .nullable()
+        .optional()
+        .describe(taskFieldDescriptions.schedule),
+    enabled: z.boolean().optional().describe(taskFieldDescriptions.enabled),
+    metadata: metadataSchema
+        .optional()
+        .describe("Your own key-value data. Replaces the current metadata."),
 })
     .strict()
     .refine(hasObjectKeys, {
@@ -139,7 +164,12 @@ export const updateTaskBodySchema = z
 // `POST /v1/tasks/{taskId}/runs` — optional client idempotency key.
 export const createTaskRunBodySchema = z
     .object({
-    idempotencyKey: z.string().trim().min(1).optional(),
+    idempotencyKey: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Your own key for this run. Retrying with the same key returns the same run instead of starting another."),
 })
     .strict();
 /**

package/dist/contracts/entities/tenants.d.ts

@@ -1,32 +1,4 @@
 import { z } from "zod";
-/**
- * `GET /v1/me` (JWT-only) — the tenant record. `authUserId` is a uuid
- * referencing `auth.users(id)` per the migration.
- */
-export declare const tenantSchema: z.ZodObject<{
-    id: z.ZodString;
-    authUserId: z.ZodUUID;
-    email: z.ZodString;
-    name: z.ZodString;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-}, z.core.$strip>;
-export declare const subscriptionStatusSchema: z.ZodEnum<{
-    active: "active";
-    inactive: "inactive";
-}>;
-export declare const tenantResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    authUserId: z.ZodUUID;
-    email: z.ZodString;
-    name: z.ZodString;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-    subscriptionStatus: z.ZodEnum<{
-        active: "active";
-        inactive: "inactive";
-    }>;
-}, z.core.$strip>;
 /**
  * Tenant deletion lifecycle — `requestedAt` marks the tenant deleting and
  * `deletesAt` is the scheduled permanent-deletion time (24 hours after
@@ -76,5 +48,7 @@ export declare const updateTenantSettingsBodySchema: z.ZodObject<{
         resetDay: z.ZodNumber;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
+export type Quota = z.infer<typeof quotaSchema>;
+export type TenantDeletion = z.infer<typeof tenantDeletionSchema>;
 export type TenantSettingsResponse = z.infer<typeof tenantSettingsResponseSchema>;
 export type UpdateTenantSettingsBody = z.infer<typeof updateTenantSettingsBodySchema>;

package/dist/contracts/entities/tenants.js

@@ -1,25 +1,6 @@
 import { z } from "zod";
-import { tenantIdSchema } from "../ids.js";
 import { MAX_QUOTA_RESET_DAY, MAX_TENANT_NAME_LENGTH, MIN_QUOTA_RESET_DAY, } from "../limitations.js";
 import { atLeastOneFieldMessage, hasObjectKeys } from "../utils.js";
-/**
- * `GET /v1/me` (JWT-only) — the tenant record. `authUserId` is a uuid
- * referencing `auth.users(id)` per the migration.
- */
-export const tenantSchema = z
-    .object({
-    id: tenantIdSchema,
-    authUserId: z.uuid(),
-    email: z.string().min(1),
-    name: z.string().min(1),
-    createdAt: z.iso.datetime({ offset: true }),
-    updatedAt: z.iso.datetime({ offset: true }),
-})
-    .strip();
-export const subscriptionStatusSchema = z.enum(["active", "inactive"]);
-export const tenantResponseSchema = tenantSchema
-    .extend({ subscriptionStatus: subscriptionStatusSchema })
-    .strip();
 /**
  * Tenant deletion lifecycle — `requestedAt` marks the tenant deleting and
  * `deletesAt` is the scheduled permanent-deletion time (24 hours after
@@ -62,9 +43,21 @@ export const tenantSettingsResponseSchema = tenantSettingsSchema
     .strip();
 export const updateTenantSettingsBodySchema = z
     .object({
-    monetizationEnabled: z.boolean().optional(),
-    name: z.string().trim().min(1).max(MAX_TENANT_NAME_LENGTH).optional(),
-    quota: quotaSchema.nullable().optional(),
+    monetizationEnabled: z
+        .boolean()
+        .optional()
+        .describe("Bill usage to your end users through your merchant account. Turning it off drops usage events your merchant has not yet accepted."),
+    name: z
+        .string()
+        .trim()
+        .min(1)
+        .max(MAX_TENANT_NAME_LENGTH)
+        .optional()
+        .describe("Display name of your tenant."),
+    quota: quotaSchema
+        .nullable()
+        .optional()
+        .describe("The whole monthly quota, replacing the current one, or `null` to remove it. Send `monthlyTokenLimit`, `monthlyRequestLimit`, and `resetDay`, with at least one limit set."),
 })
     .strict()
     .refine(hasObjectKeys, {

package/dist/contracts/entities/usage.d.ts

@@ -35,9 +35,9 @@ export declare const usageTotalsSchema: z.ZodObject<{
     durationMs: z.ZodNumber;
 }, z.core.$strip>;
 export declare const sessionUsageQuerySchema: z.ZodObject<{
-    sessionIds: z.ZodArray<z.ZodString>;
     from: z.ZodOptional<z.ZodISODate>;
     to: z.ZodOptional<z.ZodISODate>;
+    sessionIds: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 export declare const sessionUsageResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{

package/dist/contracts/entities/usage.js

@@ -34,20 +34,30 @@ function validateUsageRange(value, ctx) {
         }
     }
 }
+const usageRangeFields = {
+    from: z.iso
+        .date()
+        .optional()
+        .describe("First UTC day to include, as `YYYY-MM-DD`. Send it with `to`, or leave both out for the last 30 days ending today."),
+    to: z.iso
+        .date()
+        .optional()
+        .describe(`Last UTC day to include, as \`YYYY-MM-DD\`. It must not be before \`from\` and can be at most ${MAX_USAGE_RANGE_DAYS} days after it.`),
+};
 /**
  * Query for the bounded dashboard-oriented usage overview. The date range has
  * the same semantics as `UsageQuery`; `limit` bounds each ranking.
  */
 export const usageOverviewQuerySchema = z
     .object({
-    from: z.iso.date().optional(),
-    to: z.iso.date().optional(),
+    ...usageRangeFields,
     limit: z
         .number()
         .int()
         .min(1)
         .max(MAX_USAGE_OVERVIEW_TOP_N)
-        .default(DEFAULT_USAGE_OVERVIEW_TOP_N),
+        .default(DEFAULT_USAGE_OVERVIEW_TOP_N)
+        .describe(`Rows to return in each ranked breakdown (\`byAgent\`, \`byUser\`, \`byModel\`), from 1 to ${MAX_USAGE_OVERVIEW_TOP_N}.`),
 })
     .strict()
     .superRefine(validateUsageRange);
@@ -89,9 +99,9 @@ export const sessionUsageQuerySchema = z
         .max(100)
         .refine(hasUniqueValues, {
         message: "Session ids must be unique.",
-    }),
-    from: z.iso.date().optional(),
-    to: z.iso.date().optional(),
+    })
+        .describe("One to 100 distinct session IDs. Every session must be visible to the caller."),
+    ...usageRangeFields,
 })
     .strict()
     .superRefine(validateUsageRange);

package/dist/contracts/entities/workspaces.d.ts

@@ -34,11 +34,11 @@ export declare const workspaceSchema: z.ZodObject<{
     updatedAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export declare const createWorkspaceBodySchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
     tier: z.ZodDefault<z.ZodEnum<{
         core: "core";
         plus: "plus";
     }>>;
+    name: z.ZodOptional<z.ZodString>;
     userId: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     networkPolicy: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/contracts/entities/workspaces.js

@@ -38,22 +38,38 @@ export const workspaceSchema = z
     updatedAt: z.iso.datetime({ offset: true }),
 })
     .strip();
+const networkPolicyDescription = "Which hosts the workspace can reach: `unrestricted`, `allowlist` with `allowedHosts`, or `offline`.";
 export const createWorkspaceBodySchema = z
     .object({
-    name: workspaceNameSchema.optional(),
-    tier: workspaceTierSchema.default("core"),
-    userId: userIdSchema.default(""),
-    metadata: metadataSchema.default({}),
-    networkPolicy: workspaceNetworkPolicySchema.default({
-        mode: "unrestricted",
-    }),
+    tier: workspaceTierSchema
+        .default("core")
+        .describe("Workspace tier, fixed at creation. Core loses its files when the workspace stops; Plus keeps them when it stops while idle."),
+    name: workspaceNameSchema
+        .optional()
+        .describe(`Display name, up to ${MAX_WORKSPACE_NAME_LENGTH} characters. Leave it out for an unnamed workspace.`),
+    userId: userIdSchema
+        .default("")
+        .describe('Your own ID for the end user who owns the workspace. `""` means a tenant-level workspace. It cannot be changed later.'),
+    metadata: metadataSchema
+        .default({})
+        .describe("Your own key-value data, returned as sent."),
+    networkPolicy: workspaceNetworkPolicySchema
+        .default({ mode: "unrestricted" })
+        .describe(networkPolicyDescription),
 })
     .strict();
 export const updateWorkspaceBodySchema = z
     .object({
-    name: workspaceNameSchema.nullable().optional(),
-    metadata: metadataSchema.optional(),
-    networkPolicy: workspaceNetworkPolicySchema.optional(),
+    name: workspaceNameSchema
+        .nullable()
+        .optional()
+        .describe(`New display name, up to ${MAX_WORKSPACE_NAME_LENGTH} characters, or \`null\` to clear it.`),
+    metadata: metadataSchema
+        .optional()
+        .describe("Replaces the workspace's metadata."),
+    networkPolicy: workspaceNetworkPolicySchema
+        .optional()
+        .describe(`Replaces the network policy. ${networkPolicyDescription}`),
 })
     .strict()
     .refine(hasObjectKeys, { message: "At least one field is required." });

package/dist/contracts/index.d.ts

@@ -4,28 +4,33 @@ export type { ApprovalDecision, ApprovalPolicy, ToolExecutionReference, ToolRefe
 export { approvalDecisionSchema, approvalPolicySchema, toolExecutionReferenceSchema, toolReferenceSchema, } from "./entities/agent-approval.ts";
 export type { AgentToolDefinition, AgentToolFileAccessTag, AgentToolGroupTag, AgentToolName, AgentToolTag, AgentToolTags, } from "./entities/agent-tools.ts";
 export { AGENT_TOOL_FILE_ACCESS_TAGS, AGENT_TOOL_GROUPS, AGENT_TOOL_TAGS, AGENT_TOOLS, agentToolNames, chatFunctionNameSchema, } from "./entities/agent-tools.ts";
-export { agentConfigSchema, agentResponseSchema, agentStatusSchema, agentsListQuerySchema, agentsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.ts";
-export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.ts";
-export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.ts";
+export type { AgentStatus } from "./entities/agents.ts";
+export { agentConfigSchema, agentInstructionsSchema, agentModelIdSchema, agentResponseSchema, agentStatusSchema, agentsListQuerySchema, agentsResponseSchema, agentToolsSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.ts";
+export { artifactDownloadUrlResponseSchema, artifactFilenameSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.ts";
+export { attributionCreateInputSchema, metadataSchema, userIdSchema, } from "./entities/attribution.ts";
 export type { ChatFunctionCallEvent, ChatFunctionDefinition, ChatFunctionDefinitions, ChatFunctionOutcome, ClaimChatFunctionBody, PromptVariables, ResolveChatFunctionBody, UsageSummary, } from "./entities/chat.ts";
 export { blazingAgentsChatMessageMetadataSchema, chatFunctionCallEventSchema, chatFunctionDefinitionSchema, chatFunctionDefinitionsSchema, chatFunctionOutcomeSchema, chatModeSchema, chatRequestBodySchema, chatTriggerSchema, claimChatFunctionBodySchema, claimChatFunctionResponseSchema, generationRequestBodySchema, jsonSchemaShapeSchema, MAX_CHAT_FUNCTION_DEFINITIONS_BYTES, MAX_CHAT_FUNCTION_PAYLOAD_BYTES, MAX_CHAT_FUNCTIONS, promptVariablesSchema, resolveChatFunctionBodySchema, resolveChatFunctionResponseSchema, usageSummarySchema, } from "./entities/chat.ts";
 export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatDeliveriesResponseSchema, chatDeliveryListSchema, chatDeliveryListStatusSchema, chatDeliveryResultSchema, chatDeliverySchema, chatDeliveryStatusSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, repairChatDeliveryBodySchema, rotateChatConnectionBodySchema, tenantChatDeliverySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.ts";
-export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.ts";
-export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, updateMemoryBodySchema, } from "./entities/memories.ts";
-export { createMerchantConnectionBodySchema, merchantBindingResponseSchema, merchantBindingsResponseSchema, merchantConnectionResponseSchema, merchantConnectionSchema, merchantConnectionStatusSchema, merchantCustomerBindingSchema, merchantEnvironmentSchema, merchantGuardSchema, merchantProviderSchema, merchantUsageEventNextAction, merchantUsageEventNextActionSchema, merchantUsageEventSchema, merchantUsageEventStatusSchema, merchantUsageEventsResponseSchema, merchantUsageSummaryQuerySchema, merchantUsageSummaryResponseSchema, merchantUsageSummarySchema, merchantWorkflowIssueSchema, updateMerchantConnectionBodySchema, upsertMerchantBindingBodySchema, } from "./entities/merchant.ts";
+export type { McpConnectionLiveDetails, McpConnectionTestErrorCode, } from "./entities/mcp-connections.ts";
+export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, forwardedMetadataKeysSchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionLiveDetailsSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.ts";
+export type { CreateMemoryBody, Memory, UpdateMemoryBody, } from "./entities/memories.ts";
+export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, memoryTextSchema, updateMemoryBodySchema, } from "./entities/memories.ts";
+export { createMerchantConnectionBodySchema, merchantBindingResponseSchema, merchantBindingsResponseSchema, merchantConnectionResponseSchema, merchantConnectionSchema, merchantConnectionStatusSchema, merchantCustomerBindingSchema, merchantEnvironmentSchema, merchantGuardSchema, merchantProviderSchema, merchantUsageEventNextAction, merchantUsageEventNextActionSchema, merchantUsageEventResponseSchema, merchantUsageEventSchema, merchantUsageEventStatusSchema, merchantUsageEventsResponseSchema, merchantUsageSummaryQuerySchema, merchantUsageSummaryResponseSchema, merchantUsageSummarySchema, merchantWorkflowIssueSchema, updateMerchantConnectionBodySchema, upsertMerchantBindingBodySchema, } from "./entities/merchant.ts";
 export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptsListQuerySchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.ts";
 export { createProviderBodySchema, providerListItemSchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.ts";
 export type { ChatSteerConsumedEvent, SessionActivity, SessionInput, SessionInputResponse, SessionInputState, SessionInputsQuery, SessionInputsResponse, StopSessionBody, StopSessionResponse, SubmitSessionInputBody, } from "./entities/session-inputs.ts";
 export { chatSteerConsumedEventSchema, sessionActivitySchema, sessionInputRequestIdSchema, sessionInputResponseSchema, sessionInputSchema, sessionInputStateSchema, sessionInputsQuerySchema, sessionInputsResponseSchema, stopSessionBodySchema, stopSessionResponseSchema, submitSessionInputBodySchema, } from "./entities/session-inputs.ts";
-export type { ContinueToolApprovalsBody, SessionForkedFrom, ToolApprovalContinuationState, ToolApprovalDecision, ToolApprovalsResponse, TurnStreamErrorEvent, } from "./entities/sessions.ts";
-export { continueToolApprovalsBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionForkedFromSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, turnStreamErrorEventSchema, } from "./entities/sessions.ts";
-export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.ts";
+export type { ContinueToolApprovalsBody, LatestSessionListItem, SessionForkedFrom, SessionListItem, SessionMessage, ToolApprovalContinuationState, ToolApprovalDecision, ToolApprovalsResponse, TurnStreamErrorEvent, } from "./entities/sessions.ts";
+export { continueToolApprovalsBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionForkedFromSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, turnStreamErrorEventSchema, } from "./entities/sessions.ts";
+export { copySkillBodySchema, createSkillBodySchema, skillArchiveTypeSchema, skillCopyResultsSchema, skillDescriptionSchema, skillDetailSchema, skillFilePathSchema, skillMetadataSchema, skillNameSchema, skillSchema, skillsListResponseSchema, } from "./entities/skills.ts";
 export type { SpendingLimit, SpendingLimitResponse, SpendingLimitStopDetails, UpdateSpendingLimitBody, } from "./entities/spending-limits.ts";
 export { nextSpendingLimitReset, spendingLimitPeriodSchema, spendingLimitResetIntervalSchema, spendingLimitResponseSchema, spendingLimitSchema, spendingLimitStopDetailsSchema, updateSpendingLimitBodySchema, } from "./entities/spending-limits.ts";
-export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskCronConfigSchema, taskIntervalConfigSchema, taskListItemSchema, taskOnceConfigSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleInputSchema, taskScheduleKindSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.ts";
-export { quotaSchema, subscriptionStatusSchema, tenantDeletionSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.ts";
+export type { CreateTaskBody, TaskListItem, TaskRunStatus, TaskScheduleInput, UpdateTaskBody, } from "./entities/tasks.ts";
+export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskCronConfigSchema, taskIntervalConfigSchema, taskLatestRunSchema, taskListItemSchema, taskOnceConfigSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleInputSchema, taskScheduleKindSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.ts";
+export type { Quota, TenantDeletion, UpdateTenantSettingsBody, } from "./entities/tenants.ts";
+export { quotaSchema, tenantDeletionSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.ts";
 export type { SessionUsageQuery, SessionUsageResponse, UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageResponse, UsageTotals, } from "./entities/usage.ts";
 export { sessionUsageQuerySchema, sessionUsageResponseSchema, usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.ts";
 export type { WorkspaceTier } from "./entities/workspaces.ts";
-export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceSchema, workspacesListResponseSchema, workspaceTierSchema, } from "./entities/workspaces.ts";
-export { agentIdSchema, apiKeyTokenSchema, functionCallIdSchema, isAdminAgentId, promptIdSchema, sessionIdSchema, } from "./ids.ts";
+export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceNetworkPolicySchema, workspaceSchema, workspacesListResponseSchema, workspaceTierSchema, } from "./entities/workspaces.ts";
+export { agentIdSchema, apiKeyTokenSchema, chatDeliveryIdSchema, functionCallIdSchema, isAdminAgentId, merchantUsageEventIdSchema, promptIdSchema, sessionIdSchema, } from "./ids.ts";

package/dist/contracts/index.js

@@ -3,22 +3,22 @@
 export { receivedApiErrorResponseSchema } from "./api.js";
 export { approvalDecisionSchema, approvalPolicySchema, toolExecutionReferenceSchema, toolReferenceSchema, } from "./entities/agent-approval.js";
 export { AGENT_TOOL_FILE_ACCESS_TAGS, AGENT_TOOL_GROUPS, AGENT_TOOL_TAGS, AGENT_TOOLS, agentToolNames, chatFunctionNameSchema, } from "./entities/agent-tools.js";
-export { agentConfigSchema, agentResponseSchema, agentStatusSchema, agentsListQuerySchema, agentsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.js";
-export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.js";
-export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.js";
+export { agentConfigSchema, agentInstructionsSchema, agentModelIdSchema, agentResponseSchema, agentStatusSchema, agentsListQuerySchema, agentsResponseSchema, agentToolsSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.js";
+export { artifactDownloadUrlResponseSchema, artifactFilenameSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.js";
+export { attributionCreateInputSchema, metadataSchema, userIdSchema, } from "./entities/attribution.js";
 export { blazingAgentsChatMessageMetadataSchema, chatFunctionCallEventSchema, chatFunctionDefinitionSchema, chatFunctionDefinitionsSchema, chatFunctionOutcomeSchema, chatModeSchema, chatRequestBodySchema, chatTriggerSchema, claimChatFunctionBodySchema, claimChatFunctionResponseSchema, generationRequestBodySchema, jsonSchemaShapeSchema, MAX_CHAT_FUNCTION_DEFINITIONS_BYTES, MAX_CHAT_FUNCTION_PAYLOAD_BYTES, MAX_CHAT_FUNCTIONS, promptVariablesSchema, resolveChatFunctionBodySchema, resolveChatFunctionResponseSchema, usageSummarySchema, } from "./entities/chat.js";
 export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatDeliveriesResponseSchema, chatDeliveryListSchema, chatDeliveryListStatusSchema, chatDeliveryResultSchema, chatDeliverySchema, chatDeliveryStatusSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, repairChatDeliveryBodySchema, rotateChatConnectionBodySchema, tenantChatDeliverySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.js";
-export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.js";
-export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, updateMemoryBodySchema, } from "./entities/memories.js";
-export { createMerchantConnectionBodySchema, merchantBindingResponseSchema, merchantBindingsResponseSchema, merchantConnectionResponseSchema, merchantConnectionSchema, merchantConnectionStatusSchema, merchantCustomerBindingSchema, merchantEnvironmentSchema, merchantGuardSchema, merchantProviderSchema, merchantUsageEventNextAction, merchantUsageEventNextActionSchema, merchantUsageEventSchema, merchantUsageEventStatusSchema, merchantUsageEventsResponseSchema, merchantUsageSummaryQuerySchema, merchantUsageSummaryResponseSchema, merchantUsageSummarySchema, merchantWorkflowIssueSchema, updateMerchantConnectionBodySchema, upsertMerchantBindingBodySchema, } from "./entities/merchant.js";
+export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, forwardedMetadataKeysSchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionLiveDetailsSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.js";
+export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, memoryTextSchema, updateMemoryBodySchema, } from "./entities/memories.js";
+export { createMerchantConnectionBodySchema, merchantBindingResponseSchema, merchantBindingsResponseSchema, merchantConnectionResponseSchema, merchantConnectionSchema, merchantConnectionStatusSchema, merchantCustomerBindingSchema, merchantEnvironmentSchema, merchantGuardSchema, merchantProviderSchema, merchantUsageEventNextAction, merchantUsageEventNextActionSchema, merchantUsageEventResponseSchema, merchantUsageEventSchema, merchantUsageEventStatusSchema, merchantUsageEventsResponseSchema, merchantUsageSummaryQuerySchema, merchantUsageSummaryResponseSchema, merchantUsageSummarySchema, merchantWorkflowIssueSchema, updateMerchantConnectionBodySchema, upsertMerchantBindingBodySchema, } from "./entities/merchant.js";
 export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptsListQuerySchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.js";
 export { createProviderBodySchema, providerListItemSchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.js";
 export { chatSteerConsumedEventSchema, sessionActivitySchema, sessionInputRequestIdSchema, sessionInputResponseSchema, sessionInputSchema, sessionInputStateSchema, sessionInputsQuerySchema, sessionInputsResponseSchema, stopSessionBodySchema, stopSessionResponseSchema, submitSessionInputBodySchema, } from "./entities/session-inputs.js";
-export { continueToolApprovalsBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionForkedFromSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, turnStreamErrorEventSchema, } from "./entities/sessions.js";
-export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.js";
+export { continueToolApprovalsBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionForkedFromSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, turnStreamErrorEventSchema, } from "./entities/sessions.js";
+export { copySkillBodySchema, createSkillBodySchema, skillArchiveTypeSchema, skillCopyResultsSchema, skillDescriptionSchema, skillDetailSchema, skillFilePathSchema, skillMetadataSchema, skillNameSchema, skillSchema, skillsListResponseSchema, } from "./entities/skills.js";
 export { nextSpendingLimitReset, spendingLimitPeriodSchema, spendingLimitResetIntervalSchema, spendingLimitResponseSchema, spendingLimitSchema, spendingLimitStopDetailsSchema, updateSpendingLimitBodySchema, } from "./entities/spending-limits.js";
-export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskCronConfigSchema, taskIntervalConfigSchema, taskListItemSchema, taskOnceConfigSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleInputSchema, taskScheduleKindSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.js";
-export { quotaSchema, subscriptionStatusSchema, tenantDeletionSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.js";
+export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskCronConfigSchema, taskIntervalConfigSchema, taskLatestRunSchema, taskListItemSchema, taskOnceConfigSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleInputSchema, taskScheduleKindSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.js";
+export { quotaSchema, tenantDeletionSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.js";
 export { sessionUsageQuerySchema, sessionUsageResponseSchema, usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.js";
-export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceSchema, workspacesListResponseSchema, workspaceTierSchema, } from "./entities/workspaces.js";
-export { agentIdSchema, apiKeyTokenSchema, functionCallIdSchema, isAdminAgentId, promptIdSchema, sessionIdSchema, } from "./ids.js";
+export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceNetworkPolicySchema, workspaceSchema, workspacesListResponseSchema, workspaceTierSchema, } from "./entities/workspaces.js";
+export { agentIdSchema, apiKeyTokenSchema, chatDeliveryIdSchema, functionCallIdSchema, isAdminAgentId, merchantUsageEventIdSchema, promptIdSchema, sessionIdSchema, } from "./ids.js";

package/dist/contracts/limitations.d.ts

@@ -10,8 +10,8 @@ export declare const MAX_WORKSPACE_NAME_LENGTH = 80;
 export declare const MAX_SKILL_NAME_LENGTH = 64;
 export declare const MAX_SKILL_DESCRIPTION_LENGTH = 1024;
 export declare const MAX_SKILL_COPY_DESTINATIONS = 30;
-export declare const DEFAULT_PROMPTS_LIST_LIMIT = 50;
-export declare const MAX_PROMPTS_LIST_LIMIT = 100;
+export declare const DEFAULT_RESOURCES_LIST_LIMIT = 50;
+export declare const MAX_RESOURCES_LIST_LIMIT = 100;
 export declare const MAX_PROMPT_TEMPLATE_BYTES: number;
 export declare const MAX_PROMPT_VARIABLES = 10;
 export declare const MAX_PROMPT_NAME_LENGTH = 80;
@@ -38,8 +38,6 @@ export declare const MAX_MCP_ATTACHMENT_METADATA_KEYS = 32;
 export declare const MAX_MCP_ATTACHMENT_METADATA_KEY_LENGTH = 64;
 /** Agents — name ≤ 80, instructions ≤ 3000. */
 export declare const MAX_AGENT_NAME_LENGTH = 80;
-export declare const DEFAULT_AGENTS_LIST_LIMIT = 50;
-export declare const MAX_AGENTS_LIST_LIMIT = 100;
 export declare const MAX_AGENT_INSTRUCTIONS_LENGTH = 3000;
 /** Artifacts — 10 MiB per file. */
 export declare const MAX_ARTIFACT_BYTES: number;

package/dist/contracts/limitations.js

@@ -10,8 +10,8 @@ export const MAX_WORKSPACE_NAME_LENGTH = 80;
 export const MAX_SKILL_NAME_LENGTH = 64;
 export const MAX_SKILL_DESCRIPTION_LENGTH = 1024;
 export const MAX_SKILL_COPY_DESTINATIONS = 30;
-export const DEFAULT_PROMPTS_LIST_LIMIT = 50;
-export const MAX_PROMPTS_LIST_LIMIT = 100;
+export const DEFAULT_RESOURCES_LIST_LIMIT = 50;
+export const MAX_RESOURCES_LIST_LIMIT = 100;
 export const MAX_PROMPT_TEMPLATE_BYTES = 10 * 1024;
 export const MAX_PROMPT_VARIABLES = 10;
 export const MAX_PROMPT_NAME_LENGTH = 80;
@@ -38,8 +38,6 @@ export const MAX_MCP_ATTACHMENT_METADATA_KEYS = 32;
 export const MAX_MCP_ATTACHMENT_METADATA_KEY_LENGTH = 64;
 /** Agents — name ≤ 80, instructions ≤ 3000. */
 export const MAX_AGENT_NAME_LENGTH = 80;
-export const DEFAULT_AGENTS_LIST_LIMIT = 50;
-export const MAX_AGENTS_LIST_LIMIT = 100;
 export const MAX_AGENT_INSTRUCTIONS_LENGTH = 3000;
 /** Artifacts — 10 MiB per file. */
 export const MAX_ARTIFACT_BYTES = 10 * 1024 * 1024;

package/dist/direct-chat-transport.js

@@ -2,6 +2,7 @@ import { lastAssistantMessageIsCompleteWithApprovalResponses, } from "ai";
 import { extractApprovalDecisions } from "./approvals.js";
 import { ChatStreamTransport } from "./chat-stream-transport.js";
 import { sessionIdSchema } from "./contracts/ids.js";
+import { parseClientInput } from "./errors.js";
 /** Connects useChat directly to the SDK, including native streaming fetch clients. */
 export class BlazingAgentsDirectChatTransport extends ChatStreamTransport {
     #options;
@@ -16,7 +17,7 @@ export class BlazingAgentsDirectChatTransport extends ChatStreamTransport {
         this.#sessionId =
             options.sessionId === undefined
                 ? undefined
-                : sessionIdSchema.parse(options.sessionId);
+                : parseClientInput(sessionIdSchema, options.sessionId, "sessionId");
     }
     /**
      * Submits the supplied user messages directly to the SDK chat endpoint.

package/dist/errors.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import type { BlazingAgentsErrorCode } from "./types.ts";
 declare const BLAZING_AGENTS_ERROR_SYMBOL: unique symbol;
 export declare class BlazingAgentsError extends Error {
@@ -39,4 +40,14 @@ export declare class BlazingAgentsError extends Error {
      */
     static isInstance(error: unknown): error is BlazingAgentsError;
 }
+/**
+ * Parses caller input the SDK must check before any request, such as a value
+ * that becomes a header or transport state.
+ * @param schema - Schema the value must satisfy.
+ * @param value - Caller-supplied value.
+ * @param param - Name of the caller parameter, reported on the error.
+ * @returns The parsed value.
+ * @throws BlazingAgentsError - With code `invalid_request` if the value is invalid.
+ */
+export declare function parseClientInput<Schema extends z.ZodType>(schema: Schema, value: unknown, param: string): z.output<Schema>;
 export {};

package/dist/errors.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 /**
  * The SDK's single error class. Server codes remain open for forward
  * compatibility; SDK-local codes distinguish transport, response, abort, and
@@ -53,3 +54,23 @@ export class BlazingAgentsError extends Error {
         return BLAZING_AGENTS_ERROR_SYMBOL in error;
     }
 }
+/**
+ * Parses caller input the SDK must check before any request, such as a value
+ * that becomes a header or transport state.
+ * @param schema - Schema the value must satisfy.
+ * @param value - Caller-supplied value.
+ * @param param - Name of the caller parameter, reported on the error.
+ * @returns The parsed value.
+ * @throws BlazingAgentsError - With code `invalid_request` if the value is invalid.
+ */
+export function parseClientInput(schema, value, param) {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        throw new BlazingAgentsError({
+            code: "invalid_request",
+            message: `Invalid ${param}: ${z.prettifyError(parsed.error)}`,
+            param,
+        }, { cause: parsed.error });
+    }
+    return parsed.data;
+}

package/dist/http.d.ts

@@ -2,7 +2,9 @@ import { BlazingAgentsError } from "./errors.ts";
 import type { HttpConfig, RequestOptions } from "./types.ts";
 /**
  * Builds an endpoint path, encoding each interpolated value so it stays inside
- * one path segment or query value.
+ * one path segment. `encodeURIComponent` leaves `.` and `..` unchanged, and
+ * URL normalization would resolve them against the parent path, so those and
+ * the empty segment are rejected.
  */
 export declare function apiPath(template: TemplateStringsArray, ...values: string[]): string;
 /**