@purpleschool/gptbot 0.13.21 → 0.14.1-stage-2

package/build/commands/b2b-compatible/anthropic-messages.command.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicMessagesCommand = exports.AnthropicMessageSchema = exports.AnthropicSystemContentBlockSchema = exports.AnthropicMessageContentBlockSchema = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common.schemas");
+const AnthropicCacheControlSchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+})
+    .passthrough();
+const AnthropicTextBlockSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('text'),
+    text: zod_1.z.string(),
+    cache_control: AnthropicCacheControlSchema.optional(),
+})
+    .passthrough();
+const AnthropicBase64SourceSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('base64'),
+    media_type: zod_1.z.string(),
+    data: zod_1.z.string(),
+})
+    .passthrough();
+const AnthropicUrlSourceSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('url'),
+    url: zod_1.z.string(),
+})
+    .passthrough();
+const AnthropicFileSourceSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('file'),
+    file_id: zod_1.z.string(),
+})
+    .passthrough();
+const AnthropicTextSourceSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('text'),
+    media_type: zod_1.z.string().optional(),
+    data: zod_1.z.string(),
+})
+    .passthrough();
+const AnthropicImageBlockSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('image'),
+    source: zod_1.z.discriminatedUnion('type', [
+        AnthropicBase64SourceSchema,
+        AnthropicUrlSourceSchema,
+        AnthropicFileSourceSchema,
+    ]),
+    cache_control: AnthropicCacheControlSchema.optional(),
+})
+    .passthrough();
+const AnthropicDocumentBlockSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('document'),
+    source: zod_1.z.discriminatedUnion('type', [
+        AnthropicBase64SourceSchema,
+        AnthropicUrlSourceSchema,
+        AnthropicFileSourceSchema,
+        AnthropicTextSourceSchema,
+    ]),
+    title: zod_1.z.string().optional(),
+    cache_control: AnthropicCacheControlSchema.optional(),
+})
+    .passthrough();
+const AnthropicUnknownContentBlockSchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+})
+    .passthrough();
+exports.AnthropicMessageContentBlockSchema = zod_1.z.union([
+    AnthropicTextBlockSchema,
+    AnthropicImageBlockSchema,
+    AnthropicDocumentBlockSchema,
+    AnthropicUnknownContentBlockSchema,
+]);
+exports.AnthropicSystemContentBlockSchema = zod_1.z.union([
+    AnthropicTextBlockSchema,
+    AnthropicUnknownContentBlockSchema,
+]);
+exports.AnthropicMessageSchema = zod_1.z
+    .object({
+    // `system` appears here (not just in the top-level `system` field) when the client
+    // uses the mid-conversation-system beta — Claude Code injects operator instructions
+    // as `{ role: 'system', content }` entries inside messages[].
+    role: zod_1.z.enum(['user', 'assistant', 'system']),
+    content: zod_1.z.union([zod_1.z.string(), zod_1.z.array(exports.AnthropicMessageContentBlockSchema)]),
+})
+    .passthrough();
+const AnthropicToolSchema = zod_1.z
+    .object({
+    // Custom tools (the bulk of what the Claude CLI sends) are `{ name, description,
+    // input_schema }` with NO `type`. Only server tools (web_search_*, bash_*, …)
+    // carry a `type`. Requiring it here 400s every tool-bearing request.
+    type: zod_1.z.string().optional(),
+    name: zod_1.z.string().optional(),
+    user_location: zod_1.z
+        .object({
+        type: zod_1.z.literal('approximate').optional(),
+        country: zod_1.z.string().optional(),
+        region: zod_1.z.string().optional(),
+        city: zod_1.z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+const AnthropicThinkingSchema = zod_1.z
+    .object({
+    type: zod_1.z.string().optional(),
+})
+    .passthrough();
+var AnthropicMessagesCommand;
+(function (AnthropicMessagesCommand) {
+    AnthropicMessagesCommand.HeadersSchema = common_schemas_1.AnthropicHeadersSchema;
+    AnthropicMessagesCommand.BodySchema = zod_1.z
+        .object({
+        model: zod_1.z.string(),
+        max_tokens: zod_1.z.number().int().positive(),
+        messages: zod_1.z.array(exports.AnthropicMessageSchema).min(1),
+        system: zod_1.z.union([zod_1.z.string(), zod_1.z.array(exports.AnthropicSystemContentBlockSchema)]).optional(),
+        stream: zod_1.z.boolean().optional(),
+        tools: zod_1.z.array(AnthropicToolSchema).optional(),
+        container: zod_1.z.unknown().optional(),
+        context_management: zod_1.z.unknown().optional(),
+        mcp_servers: zod_1.z.array(zod_1.z.unknown()).optional(),
+        metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+        service_tier: zod_1.z.string().optional(),
+        stop_sequences: zod_1.z.array(zod_1.z.string()).optional(),
+        temperature: zod_1.z.number().optional(),
+        thinking: AnthropicThinkingSchema.optional(),
+        tool_choice: zod_1.z.unknown().optional(),
+        top_k: zod_1.z.number().optional(),
+        top_p: zod_1.z.number().optional(),
+    })
+        .passthrough();
+    AnthropicMessagesCommand.UsageSchema = zod_1.z
+        .object({
+        input_tokens: zod_1.z.number().int().nonnegative(),
+        output_tokens: zod_1.z.number().int().nonnegative(),
+        cache_creation_input_tokens: zod_1.z.number().int().nonnegative().optional(),
+        cache_read_input_tokens: zod_1.z.number().int().nonnegative().optional(),
+    })
+        .strict();
+    AnthropicMessagesCommand.TextContentBlockResponseSchema = zod_1.z
+        .object({
+        type: zod_1.z.literal('text'),
+        text: zod_1.z.string(),
+    })
+        .strict();
+    AnthropicMessagesCommand.ResponseSchema = zod_1.z
+        .object({
+        id: zod_1.z.string(),
+        type: zod_1.z.literal('message'),
+        role: zod_1.z.literal('assistant'),
+        content: zod_1.z.array(AnthropicMessagesCommand.TextContentBlockResponseSchema),
+        model: zod_1.z.string(),
+        stop_reason: common_schemas_1.NullableStringSchema,
+        stop_sequence: common_schemas_1.NullableStringSchema,
+        usage: AnthropicMessagesCommand.UsageSchema,
+    })
+        .strict();
+    AnthropicMessagesCommand.StreamEventSchema = zod_1.z.union([
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('message_start'),
+            message: AnthropicMessagesCommand.ResponseSchema,
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('content_block_start'),
+            index: zod_1.z.number().int(),
+            content_block: AnthropicMessagesCommand.TextContentBlockResponseSchema,
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('content_block_delta'),
+            index: zod_1.z.number().int(),
+            delta: zod_1.z
+                .object({
+                type: zod_1.z.literal('text_delta'),
+                text: zod_1.z.string(),
+            })
+                .strict(),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('content_block_stop'),
+            index: zod_1.z.number().int(),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('message_delta'),
+            delta: zod_1.z
+                .object({
+                stop_reason: common_schemas_1.NullableStringSchema.optional(),
+                stop_sequence: common_schemas_1.NullableStringSchema.optional(),
+            })
+                .strict(),
+            usage: AnthropicMessagesCommand.UsageSchema.partial().optional(),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('message_stop'),
+        })
+            .strict(),
+        common_schemas_1.AnthropicErrorResponseSchema,
+    ]);
+    AnthropicMessagesCommand.ErrorResponseSchema = common_schemas_1.AnthropicErrorResponseSchema;
+})(AnthropicMessagesCommand || (exports.AnthropicMessagesCommand = AnthropicMessagesCommand = {}));

package/build/commands/b2b-compatible/anthropic-models.command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicModelsCommand = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common.schemas");
+var AnthropicModelsCommand;
+(function (AnthropicModelsCommand) {
+    AnthropicModelsCommand.HeadersSchema = common_schemas_1.AnthropicHeadersSchema;
+    AnthropicModelsCommand.ModelSchema = zod_1.z
+        .object({
+        id: zod_1.z.string(),
+        type: zod_1.z.literal('model'),
+        display_name: zod_1.z.string(),
+        created_at: zod_1.z.string().datetime(),
+    })
+        .strict();
+    AnthropicModelsCommand.ResponseSchema = zod_1.z
+        .object({
+        data: zod_1.z.array(AnthropicModelsCommand.ModelSchema),
+        first_id: zod_1.z.string().nullable(),
+        last_id: zod_1.z.string().nullable(),
+        has_more: zod_1.z.boolean(),
+    })
+        .strict();
+    AnthropicModelsCommand.ErrorResponseSchema = common_schemas_1.AnthropicErrorResponseSchema;
+})(AnthropicModelsCommand || (exports.AnthropicModelsCommand = AnthropicModelsCommand = {}));

package/build/commands/b2b-compatible/common.schemas.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompatibleFileUploadMetadataSchema = exports.AnthropicErrorResponseSchema = exports.OpenAIErrorResponseSchema = exports.AnthropicHeadersSchema = exports.OpenAIHeadersSchema = exports.NullableStringSchema = void 0;
+const zod_1 = require("zod");
+exports.NullableStringSchema = zod_1.z.string().nullable();
+exports.OpenAIHeadersSchema = zod_1.z
+    .object({
+    authorization: zod_1.z.string(),
+})
+    .strict();
+exports.AnthropicHeadersSchema = zod_1.z
+    .object({
+    'x-api-key': zod_1.z.string(),
+    'anthropic-version': zod_1.z.string().optional(),
+})
+    .strict();
+exports.OpenAIErrorResponseSchema = zod_1.z
+    .object({
+    error: zod_1.z
+        .object({
+        message: zod_1.z.string(),
+        type: zod_1.z.string(),
+        param: exports.NullableStringSchema,
+        code: exports.NullableStringSchema,
+    })
+        .strict(),
+})
+    .strict();
+exports.AnthropicErrorResponseSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('error'),
+    error: zod_1.z
+        .object({
+        type: zod_1.z.string(),
+        message: zod_1.z.string(),
+    })
+        .strict(),
+})
+    .strict();
+exports.CompatibleFileUploadMetadataSchema = zod_1.z
+    .object({
+    filename: zod_1.z.string(),
+    mimetype: zod_1.z.string(),
+    size: zod_1.z.number().int().nonnegative(),
+})
+    .strict();

package/build/commands/{ai-studio/canvas-tool/var-gen → b2b-compatible}/index.js

@@ -14,6 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./generate-variables.command"), exports);
-__exportStar(require("./get-var-gen-config.command"), exports);
-__exportStar(require("./get-var-gen-price.command"), exports);
+__exportStar(require("./anthropic-files.command"), exports);
+__exportStar(require("./anthropic-messages.command"), exports);
+__exportStar(require("./anthropic-models.command"), exports);
+__exportStar(require("./common.schemas"), exports);
+__exportStar(require("./openai-files.command"), exports);
+__exportStar(require("./openai-models.command"), exports);
+__exportStar(require("./openai-responses.command"), exports);

package/build/commands/b2b-compatible/openai-files.command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIFilesCommand = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common.schemas");
+var OpenAIFilesCommand;
+(function (OpenAIFilesCommand) {
+    OpenAIFilesCommand.HeadersSchema = common_schemas_1.OpenAIHeadersSchema;
+    OpenAIFilesCommand.BodySchema = zod_1.z
+        .object({
+        purpose: zod_1.z.enum(['assistants', 'batch', 'fine-tune', 'vision', 'user_data', 'evals']),
+    })
+        .strict();
+    OpenAIFilesCommand.FileMetadataSchema = common_schemas_1.CompatibleFileUploadMetadataSchema;
+    OpenAIFilesCommand.ResponseSchema = zod_1.z
+        .object({
+        id: zod_1.z.string().uuid(),
+        object: zod_1.z.literal('file'),
+        bytes: zod_1.z.number().int().nonnegative(),
+        created_at: zod_1.z.number().int(),
+        filename: zod_1.z.string(),
+        purpose: OpenAIFilesCommand.BodySchema.shape.purpose,
+    })
+        .strict();
+    OpenAIFilesCommand.ErrorResponseSchema = common_schemas_1.OpenAIErrorResponseSchema;
+})(OpenAIFilesCommand || (exports.OpenAIFilesCommand = OpenAIFilesCommand = {}));

package/build/commands/b2b-compatible/openai-models.command.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIModelsCommand = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common.schemas");
+var OpenAIModelsCommand;
+(function (OpenAIModelsCommand) {
+    OpenAIModelsCommand.HeadersSchema = common_schemas_1.OpenAIHeadersSchema;
+    OpenAIModelsCommand.ModelSchema = zod_1.z
+        .object({
+        id: zod_1.z.string(),
+        object: zod_1.z.literal('model'),
+        created: zod_1.z.number().int(),
+        owned_by: zod_1.z.literal('rugpt'),
+    })
+        .strict();
+    OpenAIModelsCommand.ResponseSchema = zod_1.z
+        .object({
+        object: zod_1.z.literal('list'),
+        data: zod_1.z.array(OpenAIModelsCommand.ModelSchema),
+    })
+        .strict();
+    OpenAIModelsCommand.ErrorResponseSchema = common_schemas_1.OpenAIErrorResponseSchema;
+})(OpenAIModelsCommand || (exports.OpenAIModelsCommand = OpenAIModelsCommand = {}));

package/build/commands/b2b-compatible/openai-responses.command.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIResponsesCommand = exports.OpenAIResponseInputMessageSchema = exports.OpenAIResponseInputContentPartSchema = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common.schemas");
+const OpenAIInputTextContentPartSchema = zod_1.z
+    .object({
+    type: zod_1.z.enum(['input_text', 'text', 'output_text']),
+    text: zod_1.z.string(),
+})
+    .passthrough();
+const OpenAIInputImageContentPartSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('input_image'),
+    image_url: zod_1.z.string().optional(),
+    file_id: zod_1.z.string().optional(),
+    detail: zod_1.z.enum(['auto', 'low', 'high']).optional(),
+})
+    .passthrough();
+const OpenAIInputFileContentPartSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('input_file'),
+    file_id: zod_1.z.string().optional(),
+    file_data: zod_1.z.string().optional(),
+    file_url: zod_1.z.string().optional(),
+    filename: zod_1.z.string().optional(),
+    mime_type: zod_1.z.string().optional(),
+})
+    .passthrough();
+exports.OpenAIResponseInputContentPartSchema = zod_1.z.discriminatedUnion('type', [
+    OpenAIInputTextContentPartSchema,
+    OpenAIInputImageContentPartSchema,
+    OpenAIInputFileContentPartSchema,
+]);
+exports.OpenAIResponseInputMessageSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('message').optional(),
+    role: zod_1.z.enum(['system', 'developer', 'user', 'assistant']),
+    content: zod_1.z.union([zod_1.z.string(), zod_1.z.array(exports.OpenAIResponseInputContentPartSchema)]),
+})
+    .passthrough();
+const OpenAIAnyToolSchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+})
+    .passthrough();
+const OpenAIResponseMetadataSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
+const OpenAIResponseReasoningSchema = zod_1.z
+    .object({
+    effort: zod_1.z.string().optional(),
+    summary: zod_1.z.string().nullable().optional(),
+})
+    .passthrough();
+const OpenAIResponseTextOptionsSchema = zod_1.z
+    .object({
+    format: zod_1.z.unknown().optional(),
+    verbosity: zod_1.z.string().optional(),
+})
+    .passthrough();
+const OpenAIResponseUsageSchema = zod_1.z
+    .object({
+    input_tokens: zod_1.z.number().int().nonnegative(),
+    output_tokens: zod_1.z.number().int().nonnegative(),
+    total_tokens: zod_1.z.number().int().nonnegative(),
+    input_tokens_details: zod_1.z
+        .object({
+        cached_tokens: zod_1.z.number().int().nonnegative().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const OpenAIResponseOutputTextSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('output_text'),
+    text: zod_1.z.string(),
+    annotations: zod_1.z.array(zod_1.z.unknown()),
+})
+    .strict();
+const OpenAIResponseOutputMessageSchema = zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    type: zod_1.z.literal('message'),
+    status: zod_1.z.literal('completed'),
+    role: zod_1.z.literal('assistant'),
+    content: zod_1.z.array(OpenAIResponseOutputTextSchema),
+})
+    .strict();
+var OpenAIResponsesCommand;
+(function (OpenAIResponsesCommand) {
+    OpenAIResponsesCommand.HeadersSchema = common_schemas_1.OpenAIHeadersSchema;
+    OpenAIResponsesCommand.BodySchema = zod_1.z
+        .object({
+        model: zod_1.z.string(),
+        input: zod_1.z.union([zod_1.z.string(), zod_1.z.array(exports.OpenAIResponseInputMessageSchema).min(1)]),
+        instructions: zod_1.z.string().optional(),
+        stream: zod_1.z.boolean().optional(),
+        max_output_tokens: zod_1.z.number().int().positive().optional(),
+        tools: zod_1.z.array(OpenAIAnyToolSchema).optional(),
+        background: zod_1.z.boolean().optional(),
+        include: zod_1.z.array(zod_1.z.string()).optional(),
+        max_tool_calls: zod_1.z.number().int().positive().optional(),
+        metadata: OpenAIResponseMetadataSchema.nullable().optional(),
+        parallel_tool_calls: zod_1.z.boolean().optional(),
+        previous_response_id: zod_1.z.string().nullable().optional(),
+        prompt: zod_1.z.unknown().optional(),
+        reasoning: OpenAIResponseReasoningSchema.nullable().optional(),
+        safety_identifier: zod_1.z.string().optional(),
+        service_tier: zod_1.z.string().optional(),
+        store: zod_1.z.boolean().nullable().optional(),
+        stream_options: zod_1.z.unknown().optional(),
+        temperature: zod_1.z.number().optional(),
+        text: OpenAIResponseTextOptionsSchema.optional(),
+        tool_choice: zod_1.z.unknown().optional(),
+        top_p: zod_1.z.number().optional(),
+        truncation: zod_1.z.string().optional(),
+        user: zod_1.z.string().optional(),
+    })
+        .passthrough();
+    OpenAIResponsesCommand.UsageSchema = OpenAIResponseUsageSchema;
+    OpenAIResponsesCommand.ResponseSchema = zod_1.z
+        .object({
+        id: zod_1.z.string(),
+        object: zod_1.z.literal('response'),
+        created_at: zod_1.z.number().int(),
+        status: zod_1.z.literal('completed'),
+        model: zod_1.z.string(),
+        output: zod_1.z.array(OpenAIResponseOutputMessageSchema),
+        output_text: zod_1.z.string(),
+        usage: OpenAIResponsesCommand.UsageSchema,
+    })
+        .strict();
+    OpenAIResponsesCommand.StreamEventSchema = zod_1.z.union([
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.created'),
+            response: OpenAIResponsesCommand.ResponseSchema.omit({ status: true }).extend({
+                status: zod_1.z.literal('in_progress'),
+                output: zod_1.z.array(zod_1.z.never()),
+                output_text: zod_1.z.literal(''),
+            }),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.output_text.delta'),
+            response_id: zod_1.z.string(),
+            output_index: zod_1.z.number().int(),
+            content_index: zod_1.z.number().int(),
+            delta: zod_1.z.string(),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.output_text.done'),
+            response_id: zod_1.z.string(),
+            output_index: zod_1.z.number().int(),
+            content_index: zod_1.z.number().int(),
+            text: zod_1.z.string(),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.completed'),
+            response: OpenAIResponsesCommand.ResponseSchema,
+        })
+            .strict(),
+        common_schemas_1.OpenAIErrorResponseSchema,
+    ]);
+    OpenAIResponsesCommand.ErrorResponseSchema = common_schemas_1.OpenAIErrorResponseSchema;
+})(OpenAIResponsesCommand || (exports.OpenAIResponsesCommand = OpenAIResponsesCommand = {}));

package/build/commands/b2b-usage-log/get-b2b-usage-statistics.command.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetB2bUsageStatisticsCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const b2b_1 = require("../../models/b2b");
+const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+const DateOnlySchema = zod_1.z
+    .string()
+    .regex(DATE_ONLY_PATTERN)
+    .refine((value) => {
+    const [year, month, day] = value.split('-').map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}, { message: 'Invalid calendar date' });
+const formatLocalDate = (date) => {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+};
+const toUtcCalendarTimestamp = (value) => {
+    const [year, month, day] = value.split('-').map(Number);
+    return Date.UTC(year, month - 1, day);
+};
+var GetB2bUsageStatisticsCommand;
+(function (GetB2bUsageStatisticsCommand) {
+    GetB2bUsageStatisticsCommand.RequestQuerySchema = zod_1.z
+        .object({
+        period: zod_1.z.nativeEnum(constants_1.B2B_STATISTICS_PERIOD).default(constants_1.B2B_STATISTICS_PERIOD.THIRTY_DAYS),
+        dateFrom: DateOnlySchema.optional(),
+        dateTo: DateOnlySchema.optional(),
+        apiKeyId: zod_1.z.string().uuid().optional(),
+    })
+        .superRefine((query, context) => {
+        const isCustom = query.period === constants_1.B2B_STATISTICS_PERIOD.CUSTOM;
+        if (!isCustom) {
+            if (query.dateFrom !== undefined) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    path: ['dateFrom'],
+                    message: 'dateFrom is only allowed for custom period',
+                });
+            }
+            if (query.dateTo !== undefined) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    path: ['dateTo'],
+                    message: 'dateTo is only allowed for custom period',
+                });
+            }
+            return;
+        }
+        if (query.dateFrom === undefined) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateFrom'],
+                message: 'dateFrom is required for custom period',
+            });
+        }
+        if (query.dateTo === undefined) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'dateTo is required for custom period',
+            });
+        }
+        if (query.dateFrom === undefined || query.dateTo === undefined) {
+            return;
+        }
+        const today = formatLocalDate(new Date());
+        if (query.dateFrom > today) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateFrom'],
+                message: 'dateFrom cannot be in the future',
+            });
+        }
+        if (query.dateTo > today) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'dateTo cannot be in the future',
+            });
+        }
+        if (query.dateFrom > query.dateTo) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'dateTo must be on or after dateFrom',
+            });
+            return;
+        }
+        const inclusiveDays = (toUtcCalendarTimestamp(query.dateTo) - toUtcCalendarTimestamp(query.dateFrom)) /
+            MILLISECONDS_PER_DAY +
+            1;
+        if (inclusiveDays > 90) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'Custom period cannot exceed 90 calendar days',
+            });
+        }
+    });
+    GetB2bUsageStatisticsCommand.ResponseSchema = zod_1.z.object({
+        data: b2b_1.B2bUsageStatisticsSchema,
+    });
+})(GetB2bUsageStatisticsCommand || (exports.GetB2bUsageStatisticsCommand = GetB2bUsageStatisticsCommand = {}));

package/build/{constants/photo-studio/enums → commands/b2b-usage-log}/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./photo-studio-checkpoint-action-type.enum"), exports);
+__exportStar(require("./get-b2b-usage-statistics.command"), exports);

package/build/commands/index.js

@@ -37,7 +37,6 @@ __exportStar(require("./midjourney"), exports);
 __exportStar(require("./page"), exports);
 __exportStar(require("./order"), exports);
 __exportStar(require("./payment"), exports);
-__exportStar(require("./photo-studio"), exports);
 __exportStar(require("./product"), exports);
 __exportStar(require("./question"), exports);
 __exportStar(require("./referral"), exports);
@@ -66,6 +65,8 @@ __exportStar(require("./cabinet"), exports);
 __exportStar(require("./webmaster"), exports);
 __exportStar(require("./webmaster-click"), exports);
 __exportStar(require("./b2b"), exports);
+__exportStar(require("./b2b-usage-log"), exports);
+__exportStar(require("./b2b-compatible"), exports);
 __exportStar(require("./community"), exports);
 __exportStar(require("./user-profile"), exports);
 __exportStar(require("./team-account"), exports);

package/build/constants/b2b/enums/b2b-debit-status.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.B2B_DEBIT_STATUS = void 0;
+var B2B_DEBIT_STATUS;
+(function (B2B_DEBIT_STATUS) {
+    B2B_DEBIT_STATUS["NOT_APPLICABLE"] = "not_applicable";
+    B2B_DEBIT_STATUS["SUCCESS"] = "success";
+    B2B_DEBIT_STATUS["FAILED"] = "failed";
+})(B2B_DEBIT_STATUS || (exports.B2B_DEBIT_STATUS = B2B_DEBIT_STATUS = {}));