@openapi-flow/core 0.1.0 → 0.3.0

package/dist/review/suggestions/validate-workflow-review-suggestions.js

@@ -0,0 +1,20 @@
+import { isDeepStrictEqual } from 'node:util';
+import { createWorkflowReviewSuggestions } from './create-workflow-review-suggestions.js';
+import { workflowReviewSuggestionsRecordSchema } from '../../schemas/workflow-review-suggestions-record-schema.js';
+export function validateWorkflowReviewSuggestions(input) {
+    if (!input.review || !Array.isArray(input.review.suggestions))
+        throw new Error('Review suggestions require an original host-owned review record');
+    workflowReviewSuggestionsRecordSchema.parse(input.review);
+    const expected = createWorkflowReviewSuggestions({
+        ...input,
+        proposal: {
+            suggestions: input.review.suggestions.map(({ id, ...suggestion }) => {
+                if (!id.trim())
+                    throw new Error('Review suggestion id must be non-empty');
+                return suggestion;
+            }),
+        },
+    });
+    if (!isDeepStrictEqual(expected, input.review))
+        throw new Error('Review suggestions are stale or have modified identities, text, sources or settings');
+}

package/dist/runtime-api.d.ts

@@ -0,0 +1,9 @@
+export { materializeApiArguments } from './bindings/materialize-api-arguments.js';
+export * from './openapi/request/serialize-parameter.js';
+export { serializeFormBody } from './openapi/request/serialize-form-body.js';
+export { UnsupportedOperationError } from './openapi/common/unsupported-operation-error.js';
+export { apiResponseValidationValue } from './openapi/response/api-response-validation-value.js';
+export { pointerValue } from './bindings/json-pointer.js';
+export { listMissingRequestedApiInputs } from './arguments/clarification/list-missing-requested-api-inputs.js';
+export { assignRequestInputValue } from './bindings/assign-request-input-value.js';
+export { materializeNativeRuntimeParameters } from './inputs/native/materialize-native-runtime-parameters.js';

package/dist/runtime-api.js

@@ -0,0 +1,10 @@
+// Execution-only entrypoint: excludes catalog hashing and document intake.
+export { materializeApiArguments } from './bindings/materialize-api-arguments.js';
+export * from './openapi/request/serialize-parameter.js';
+export { serializeFormBody } from './openapi/request/serialize-form-body.js';
+export { UnsupportedOperationError } from './openapi/common/unsupported-operation-error.js';
+export { apiResponseValidationValue } from './openapi/response/api-response-validation-value.js';
+export { pointerValue } from './bindings/json-pointer.js';
+export { listMissingRequestedApiInputs } from './arguments/clarification/list-missing-requested-api-inputs.js';
+export { assignRequestInputValue } from './bindings/assign-request-input-value.js';
+export { materializeNativeRuntimeParameters } from './inputs/native/materialize-native-runtime-parameters.js';

package/dist/schemas/api-binding-planning-schema.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import type { ApiBindingPlanningMaterial } from '../types/api-binding-planning.js';
+import type { NativeOutputContract } from '../types/node-output.js';
+import type { ApiParameterObject, ApiServerObject } from '../types/api-operation.js';
+export declare const apiBindingPlanningIdentitySchema: z.ZodObject<{
+    scenario: z.ZodString;
+}, z.core.$strict>;
+/** Validate the resolved-contract container, not a second implementation of OpenAPI validation. */
+export declare const apiBindingPlanningOperationSchema: z.ZodObject<{
+    key: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    openapiVersion: z.ZodString;
+    source: z.ZodLiteral<"paths">;
+    method: z.ZodString;
+    path: z.ZodString;
+    operation: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    pathItem: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    effective: z.ZodObject<{
+        parameters: z.ZodArray<z.ZodCustom<ApiParameterObject, ApiParameterObject>>;
+        security: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        securitySchemes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        servers: z.ZodOptional<z.ZodArray<z.ZodCustom<ApiServerObject, ApiServerObject>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const apiBindingMaterialRoleSchema: z.ZodObject<{
+    purpose: z.ZodOptional<z.ZodString>;
+    requestMediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const apiBindingCallReasonsSchema: z.ZodArray<z.ZodObject<{
+    callId: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>>;
+/** Nested OAS and native data are compared to a newly derived exact source snapshot. */
+export declare const apiBindingPlanningContextSchema: z.ZodObject<{
+    scenario: z.ZodString;
+    materials: z.ZodArray<z.ZodCustom<ApiBindingPlanningMaterial, ApiBindingPlanningMaterial>>;
+    nativeOutputs: z.ZodOptional<z.ZodArray<z.ZodCustom<NativeOutputContract, NativeOutputContract>>>;
+}, z.core.$strict>;
+export declare const apiBindingPlanningRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"proposed-bindings">;
+    calls: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        bindings: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"node-output">;
+            targetPointer: z.ZodString;
+            sourceNodeId: z.ZodString;
+            sourcePointer: z.ZodString;
+        }, z.core.$strict>>;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    gaps: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        targetPointer: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    evidence: z.ZodObject<{
+        kind: z.ZodLiteral<"supplied-binding-contracts">;
+        context: z.ZodObject<{
+            scenario: z.ZodString;
+            materials: z.ZodArray<z.ZodCustom<ApiBindingPlanningMaterial, ApiBindingPlanningMaterial>>;
+            nativeOutputs: z.ZodOptional<z.ZodArray<z.ZodCustom<NativeOutputContract, NativeOutputContract>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/schemas/api-binding-planning-schema.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+export const apiBindingPlanningIdentitySchema = z.strictObject({
+    scenario: planningEvidenceTextSchema,
+});
+/** Validate the resolved-contract container, not a second implementation of OpenAPI validation. */
+export const apiBindingPlanningOperationSchema = z.object({
+    key: apiOperationKeySchema,
+    openapiVersion: planningEvidenceTextSchema,
+    source: z.literal('paths'),
+    method: planningEvidenceTextSchema,
+    path: z.string(),
+    operation: z.record(z.string(), z.unknown()),
+    pathItem: z.record(z.string(), z.unknown()),
+    effective: z.object({
+        parameters: z.array(z.custom()),
+        security: z.array(z.record(z.string(), z.array(z.string()))),
+        securitySchemes: z.record(z.string(), z.unknown()),
+        servers: z.array(z.custom()).optional(),
+    }),
+});
+export const apiBindingMaterialRoleSchema = z.strictObject({
+    purpose: planningEvidenceTextSchema.optional(),
+    requestMediaType: planningEvidenceTextSchema.optional(),
+});
+export const apiBindingCallReasonsSchema = z.array(z.strictObject({
+    callId: planningEvidenceTextSchema,
+    reason: planningEvidenceTextSchema,
+}));
+/** Nested OAS and native data are compared to a newly derived exact source snapshot. */
+export const apiBindingPlanningContextSchema = z.strictObject({
+    scenario: planningEvidenceTextSchema,
+    materials: z.array(z.custom()),
+    nativeOutputs: z.array(z.custom()).optional(),
+});
+export const apiBindingPlanningRecordSchema = z.strictObject({
+    kind: z.literal('proposed-bindings'),
+    calls: z.array(z.strictObject({
+        callId: planningEvidenceTextSchema,
+        bindings: z.array(z.strictObject({
+            kind: z.literal('node-output'),
+            targetPointer: z.string().min(1),
+            sourceNodeId: planningEvidenceTextSchema,
+            sourcePointer: z.string(),
+        })),
+        reason: planningEvidenceTextSchema,
+    })),
+    gaps: z.array(z.strictObject({
+        callId: planningEvidenceTextSchema,
+        targetPointer: z.string().min(1),
+        description: planningEvidenceTextSchema,
+    })),
+    evidence: z.strictObject({
+        kind: z.literal('supplied-binding-contracts'),
+        context: apiBindingPlanningContextSchema,
+    }),
+});

package/dist/schemas/api-input-answer-extraction-schema.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export declare const apiInputRequirementSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "missing-input": "missing-input";
+        "requested-input": "requested-input";
+    }>;
+    requestedInputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodString;
+    callId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    targetPointer: z.ZodString;
+    schema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>;
+    openapiVersion: z.ZodString;
+    operationSummary: z.ZodOptional<z.ZodString>;
+    parameterDescription: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export declare const apiInputAnswerContextSchema: z.ZodObject<{
+    reply: z.ZodString;
+    requirements: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "missing-input": "missing-input";
+            "requested-input": "requested-input";
+        }>;
+        requestedInputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodString;
+        callId: z.ZodString;
+        operation: z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>;
+        targetPointer: z.ZodString;
+        schema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>;
+        openapiVersion: z.ZodString;
+        operationSummary: z.ZodOptional<z.ZodString>;
+        parameterDescription: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const apiInputAnswerSourceSchema: z.ZodObject<{
+    sourceFormat: z.ZodEnum<{
+        text: "text";
+        json: "json";
+    }>;
+    sourceText: z.ZodString;
+    requirementId: z.ZodString;
+}, z.core.$strict>;
+export declare const apiInputAnswerSourcesSchema: z.ZodArray<z.ZodObject<{
+    sourceFormat: z.ZodEnum<{
+        text: "text";
+        json: "json";
+    }>;
+    sourceText: z.ZodString;
+    requirementId: z.ZodString;
+}, z.core.$strict>>;
+export declare const apiInputAnswerExtractionDecisionSchema: z.ZodObject<{
+    reason: z.ZodString;
+    answers: z.ZodArray<z.ZodObject<{
+        sourceFormat: z.ZodEnum<{
+            text: "text";
+            json: "json";
+        }>;
+        sourceText: z.ZodString;
+        requirementId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/schemas/api-input-answer-extraction-schema.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { apiInputLiteralSourceSchema } from './api-input-literal-source-schema.js';
+import { requestedApiInputsSchema } from './requested-api-inputs-schema.js';
+export const apiInputRequirementSchema = z.strictObject({
+    kind: z.enum(['missing-input', 'requested-input']),
+    requestedInputs: requestedApiInputsSchema.optional(),
+    id: z.string().min(1),
+    callId: z.string().min(1),
+    operation: apiOperationKeySchema,
+    targetPointer: z.string().min(1),
+    schema: z.union([z.boolean(), z.record(z.string(), z.json())]),
+    openapiVersion: z.string().min(1),
+    operationSummary: z.string().optional(),
+    parameterDescription: z.string().optional(),
+    message: z.string().min(1),
+});
+export const apiInputAnswerContextSchema = z.strictObject({
+    reply: z.string(),
+    requirements: z.array(apiInputRequirementSchema),
+});
+export const apiInputAnswerSourceSchema = apiInputLiteralSourceSchema.extend({
+    requirementId: z.string().min(1),
+});
+export const apiInputAnswerSourcesSchema = z.array(apiInputAnswerSourceSchema);
+export const apiInputAnswerExtractionDecisionSchema = z.strictObject({
+    reason: z.string().min(1),
+    answers: z.array(apiInputAnswerSourceSchema.extend({ reason: z.string().min(1) })),
+});

package/dist/schemas/api-input-literal-source-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const apiInputLiteralSourceSchema: z.ZodObject<{
+    sourceFormat: z.ZodEnum<{
+        text: "text";
+        json: "json";
+    }>;
+    sourceText: z.ZodString;
+}, z.core.$strict>;

package/dist/schemas/api-input-literal-source-schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export const apiInputLiteralSourceSchema = z.strictObject({
+    sourceFormat: z
+        .enum(['text', 'json'])
+        .describe('Use json for a quoted JSON string and include both original quotes in sourceText; json also parses explicit numbers, booleans, null, objects and arrays. Use text only for an unquoted verbatim string. Never use text for a quoted token unless the quote characters themselves are part of the requested string value. No coercion or quote repair.'),
+    sourceText: z
+        .string()
+        .min(1)
+        .describe('Exact complete substring from the selected original user message. For a quoted JSON string preserve its original quotes and escapes and use sourceFormat json. Never add/remove quotes, invent text or use a schema default.'),
+});

package/dist/schemas/api-input-source-selection-schema.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { ApiInputSourceCatalog, ApiInputJsonSourceSelection, ApiInputTextSourceSelection } from '../types/api-input-source-selection.js';
+export declare const apiInputSourceSelectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"json">;
+    candidateId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    startTokenId: z.ZodString;
+    endTokenId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const apiInputAnswerSelectionsSchema: z.ZodArray<z.ZodObject<{
+    requirementId: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        candidateId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        startTokenId: z.ZodString;
+        endTokenId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>>;
+/** Only code-owned IDs can be selected; strings and values are input-only. */
+export declare function createApiInputSourceSelectionSchema(catalog: ApiInputSourceCatalog): z.ZodUnion<z.ZodType<ApiInputJsonSourceSelection | ApiInputTextSourceSelection, unknown, z.core.$ZodTypeInternals<ApiInputJsonSourceSelection | ApiInputTextSourceSelection, unknown>>[]>;

package/dist/schemas/api-input-source-selection-schema.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export const apiInputSourceSelectionSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('json'), candidateId: z.string().min(1) }),
+    z.strictObject({
+        kind: z.literal('text'),
+        startTokenId: z.string().min(1),
+        endTokenId: z.string().min(1),
+    }),
+]);
+export const apiInputAnswerSelectionsSchema = z.array(z.strictObject({
+    requirementId: z.string().min(1),
+    source: apiInputSourceSelectionSchema,
+}));
+/** Only code-owned IDs can be selected; strings and values are input-only. */
+export function createApiInputSourceSelectionSchema(catalog) {
+    const jsonIds = catalog.json.map((candidate) => candidate.id);
+    const textIds = catalog.text.flatMap((segment) => segment.tokens.map((token) => token.id));
+    const choices = [];
+    if (jsonIds.length)
+        choices.push(z.strictObject({
+            kind: z.literal('json'),
+            candidateId: z
+                .enum(jsonIds)
+                .describe('Select a complete original JSON literal candidate. Code owns its exact text and JSON parsing, including string delimiters.'),
+        }));
+    if (textIds.length) {
+        const boundary = z.enum(textIds);
+        choices.push(z.strictObject({
+            kind: z.literal('text'),
+            startTokenId: boundary.describe('First token of the exact unquoted string. Start and end must be in the same offered text segment, in original order.'),
+            endTokenId: boundary
+                .clone()
+                .describe('Last token, inclusive, of the exact unquoted string. Code copies every original character between these boundaries, including whitespace.'),
+        }));
+    }
+    if (!choices.length)
+        throw new Error('API input source selection requires an available original source');
+    return z.union(choices);
+}

package/dist/schemas/api-literal-generation-schema.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import type { ApiArgumentValues } from '../types/api-arguments.js';
+export declare const apiLiteralGenerationIdentitySchema: z.ZodObject<{
+    callId: z.ZodString;
+    scenario: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const apiLiteralGenerationOperationSchema: z.ZodObject<{
+    key: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    method: z.ZodString;
+    path: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const apiLiteralGenerationContextSchema: z.ZodObject<{
+    scenario: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    operation: z.ZodObject<{
+        key: z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodString;
+        path: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    literalInputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    requestMediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare function createApiLiteralGenerationRecordSchema(valuesSchema: z.ZodType<ApiArgumentValues>): z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"not-needed">;
+    callId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"proposed-literals">;
+    callId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    proposedValues: z.ZodType<ApiArgumentValues, unknown, z.core.$ZodTypeInternals<ApiArgumentValues, unknown>>;
+    explanation: z.ZodObject<{
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"scenario">;
+            text: z.ZodString;
+            purpose: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"literal-input-contract">;
+            operation: z.ZodObject<{
+                key: z.ZodObject<{
+                    documentId: z.ZodString;
+                    snapshotId: z.ZodString;
+                    operationRef: z.ZodString;
+                }, z.core.$strict>;
+                method: z.ZodString;
+                path: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            requestMediaType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;

package/dist/schemas/api-literal-generation-schema.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+export const apiLiteralGenerationIdentitySchema = z.strictObject({
+    callId: planningEvidenceTextSchema,
+    scenario: planningEvidenceTextSchema,
+    purpose: planningEvidenceTextSchema.optional(),
+});
+export const apiLiteralGenerationOperationSchema = z.strictObject({
+    key: apiOperationKeySchema,
+    method: planningEvidenceTextSchema,
+    path: z.string(),
+    summary: z.string().optional(),
+    description: z.string().optional(),
+});
+export const apiLiteralGenerationContextSchema = z.strictObject({
+    scenario: planningEvidenceTextSchema,
+    purpose: planningEvidenceTextSchema.optional(),
+    operation: apiLiteralGenerationOperationSchema,
+    literalInputSchema: z.record(z.string(), z.unknown()),
+    requestMediaType: planningEvidenceTextSchema.optional(),
+});
+export function createApiLiteralGenerationRecordSchema(valuesSchema) {
+    return z.discriminatedUnion('kind', [
+        z.strictObject({
+            kind: z.literal('not-needed'),
+            callId: planningEvidenceTextSchema,
+            operation: apiOperationKeySchema,
+        }),
+        z.strictObject({
+            kind: z.literal('proposed-literals'),
+            callId: planningEvidenceTextSchema,
+            operation: apiOperationKeySchema,
+            proposedValues: valuesSchema,
+            explanation: z.strictObject({
+                reason: planningEvidenceTextSchema,
+                evidence: z.array(z.discriminatedUnion('kind', [
+                    z.strictObject({
+                        kind: z.literal('scenario'),
+                        text: z.string(),
+                        purpose: planningEvidenceTextSchema.optional(),
+                    }),
+                    z.strictObject({
+                        kind: z.literal('literal-input-contract'),
+                        operation: apiLiteralGenerationOperationSchema,
+                        schema: z.record(z.string(), z.unknown()),
+                        requestMediaType: planningEvidenceTextSchema.optional(),
+                    }),
+                ])),
+            }),
+        }),
+    ]);
+}

package/dist/schemas/api-operation-answers-schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const apiOperationAnswersSchema: z.ZodArray<z.ZodObject<{
+    questionId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>>;

package/dist/schemas/api-operation-answers-schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+export const apiOperationAnswersSchema = z
+    .array(z.strictObject({
+    questionId: z.string().min(1),
+    operation: apiOperationKeySchema,
+}))
+    .min(1);

package/dist/schemas/api-operation-candidate-schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const apiOperationCandidateSchema: z.ZodObject<{
+    key: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    source: z.ZodEnum<{
+        paths: "paths";
+        webhooks: "webhooks";
+        callbacks: "callbacks";
+    }>;
+    operationRef: z.ZodString;
+    method: z.ZodString;
+    path: z.ZodString;
+    operationId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;

package/dist/schemas/api-operation-candidate-schema.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+export const apiOperationCandidateSchema = z
+    .strictObject({
+    key: apiOperationKeySchema,
+    source: z.enum(['paths', 'webhooks', 'callbacks']),
+    operationRef: z.string().min(1),
+    method: z.string().min(1),
+    path: z.string(),
+    operationId: z.string().optional(),
+    summary: z.string(),
+    description: z.string(),
+    tags: z.array(z.string()),
+})
+    .refine((candidate) => candidate.operationRef === candidate.key.operationRef, {
+    message: 'candidate.operationRef must equal candidate.key.operationRef',
+    path: ['operationRef'],
+});

package/dist/schemas/api-operation-key-schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const apiOperationKeySchema: z.ZodObject<{
+    documentId: z.ZodString;
+    snapshotId: z.ZodString;
+    operationRef: z.ZodString;
+}, z.core.$strict>;

package/dist/schemas/api-operation-key-schema.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const apiOperationKeySchema = z.strictObject({
+    documentId: z.string().min(1),
+    snapshotId: z.string().min(1),
+    operationRef: z.string().min(1),
+});