@openapi-flow/core 0.1.0 → 0.2.0

package/dist/schemas/project-literal-input-schema.js

@@ -0,0 +1,129 @@
+import { isObject } from '../utils/is-object.js';
+import { projectLiteralArraySchema } from './project-literal-array-schema.js';
+/** Bound fields do not belong in the model's literal-value output schema. */
+export function projectLiteralInputSchema(input, targets, source) {
+    if (targets.some((tokens) => tokens.length === 0))
+        return { schema: false, hasLiteralValues: false };
+    if (!targets.length || input === false)
+        return {
+            schema: structuredClone(input),
+            hasLiteralValues: input !== false,
+        };
+    if (input === true)
+        return projectLiteralInputSchema({}, targets, source);
+    const schema = structuredClone(input);
+    if (Array.isArray(schema.type)) {
+        const variants = schema.type.map((type) => projectLiteralInputSchema({ ...schema, type }, targets, source));
+        return {
+            schema: { anyOf: variants.map((variant) => variant.schema) },
+            hasLiteralValues: variants.some((variant) => variant.hasLiteralValues),
+        };
+    }
+    if (typeof schema.type === 'string' &&
+        !['object', 'array'].includes(schema.type))
+        return { schema: false, hasLiteralValues: false };
+    const combinations = new Map();
+    const conjuncts = [];
+    for (const key of ['allOf', 'anyOf', 'oneOf']) {
+        if (!Array.isArray(schema[key]))
+            continue;
+        const projected = schema[key].map((child) => {
+            if (typeof child !== 'boolean' && !isObject(child))
+                throw new Error(`${source}.${key} must contain schemas`);
+            return projectLiteralInputSchema(child, targets, source);
+        });
+        const alternatives = projected.map((child) => child.schema);
+        delete schema[key];
+        // Bound discriminators distinguish completed values, not partial literals.
+        // Preserve simultaneous composition constraints in one conjunction; exact-one
+        // validation belongs to the untouched OAS after materialization.
+        if (key === 'allOf')
+            conjuncts.push(...alternatives);
+        else
+            conjuncts.push({ anyOf: alternatives });
+        combinations.set(key, projected);
+    }
+    if (combinations.size)
+        schema.allOf = conjuncts;
+    const combinationAllowsLiterals = [...combinations].every(([kind, children]) => kind === 'allOf'
+        ? children.every((child) => child.hasLiteralValues)
+        : children.some((child) => child.hasLiteralValues));
+    if (schema.type === 'array')
+        return projectLiteralArraySchema(schema, targets, source);
+    if (schema.type === 'object' ||
+        isObject(schema.properties) ||
+        isObject(schema.patternProperties) ||
+        schema.additionalProperties !== undefined) {
+        const properties = Object.create(null);
+        const availability = new Map();
+        for (const [name, child] of Object.entries(isObject(schema.properties) ? schema.properties : {})) {
+            if (typeof child !== 'boolean' && !isObject(child))
+                throw new Error(`${source}.properties.${name} must be a schema`);
+            properties[name] = child;
+            availability.set(name, child !== false);
+        }
+        const names = new Set(targets.map(([name]) => name));
+        for (const name of names) {
+            const children = targets
+                .filter(([token]) => token === name)
+                .map((tokens) => tokens.slice(1));
+            let child;
+            if (Object.hasOwn(properties, name))
+                child = properties[name];
+            else {
+                const patterns = Object.entries(isObject(schema.patternProperties) ? schema.patternProperties : {})
+                    .filter(([pattern]) => new RegExp(pattern).test(name))
+                    .map(([, value]) => value);
+                if (patterns.length)
+                    child = { allOf: patterns };
+                else {
+                    // OAS/JSON Schema permits additional properties unless explicitly closed.
+                    const additional = schema.additionalProperties;
+                    if (additional === false)
+                        return { schema: false, hasLiteralValues: false };
+                    if (additional !== undefined &&
+                        additional !== true &&
+                        !isObject(additional))
+                        throw new Error(`${source}.additionalProperties must be a schema`);
+                    child = additional === undefined ? true : additional;
+                }
+            }
+            const projected = projectLiteralInputSchema(child, children, `${source}/${name}`);
+            // A false property blocks re-entry through additionalProperties and patterns.
+            properties[name] = projected.schema;
+            availability.set(name, projected.hasLiteralValues);
+        }
+        schema.properties = properties;
+        // Counts describe the completed request; preceding nodes contribute keys too.
+        if (typeof schema.minProperties === 'number')
+            schema.minProperties = Math.max(0, schema.minProperties - names.size);
+        if (typeof schema.maxProperties === 'number')
+            schema.maxProperties = Math.max(0, schema.maxProperties -
+                targets.filter((tokens) => tokens.length === 1).length);
+        const open = schema.additionalProperties !== false;
+        const patterns = isObject(schema.patternProperties)
+            ? Object.values(schema.patternProperties).some((child) => child !== false)
+            : false;
+        return {
+            schema,
+            hasLiteralValues: combinationAllowsLiterals &&
+                (open || patterns || [...availability.values()].some(Boolean)),
+        };
+    }
+    if (combinations.size)
+        return {
+            schema,
+            hasLiteralValues: combinationAllowsLiterals,
+        };
+    // An unconstrained OAS schema permits both containers. Keep every container
+    // compatible with the pointer instead of guessing whether numeric keys are arrays.
+    return projectLiteralInputSchema({
+        ...schema,
+        anyOf: [
+            { type: 'object' },
+            ...(targets.every(([token]) => /^(0|[1-9][0-9]*)$/.test(token))
+                ? [{ type: 'array' }]
+                : []),
+        ],
+    }, targets, source);
+}

package/dist/types/api-argument-generation.d.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+import type { ApiArgumentProposal } from './api-arguments.js';
+import type { JsonObject } from './openapi.js';
+export type LiteralInputSchema = JsonObject | boolean;
+export interface LiteralInputProjection {
+    schema: LiteralInputSchema;
+    hasLiteralValues: boolean;
+}
+export interface ApiArgumentGenerationContract {
+    schema: z.ZodType<ApiArgumentProposal>;
+    literalInputSchema: JsonObject;
+    hasLiteralInputs: boolean;
+}

package/dist/types/api-arguments.d.ts

@@ -0,0 +1,42 @@
+import type { ApiOperationContract } from './api-operation.js';
+export type JsonValue = string | number | boolean | null | JsonValue[] | JsonValueObject;
+export interface JsonValueObject {
+    [key: string]: JsonValue;
+}
+export interface ApiArgumentValues {
+    path?: JsonValueObject;
+    query?: JsonValueObject;
+    header?: JsonValueObject;
+    cookie?: JsonValueObject;
+    querystring?: JsonValueObject;
+    body?: JsonValue;
+}
+export interface OutputBinding {
+    kind: 'node-output';
+    targetPointer: string;
+    sourceNodeId: string;
+    sourcePointer: string;
+}
+export interface ApiArgumentProposal {
+    values: ApiArgumentValues;
+}
+export interface ApiArgumentsSchemaInput {
+    operation: ApiOperationContract;
+    bindings: OutputBinding[];
+    requestMediaType?: string;
+}
+export type ApiRequestSchemaInput = Omit<ApiArgumentsSchemaInput, 'bindings'>;
+export interface ApiCallArguments extends ApiArgumentProposal {
+    callId: string;
+    bindings: OutputBinding[];
+    unresolvedInputs: string[];
+    requestMediaType?: string;
+}
+export interface ValidateApiArgumentsInput extends ApiArgumentsSchemaInput {
+    values: ApiArgumentValues;
+}
+export interface ApiArgumentValidation {
+    valid: boolean;
+    missingInputs: string[];
+    requiresRuntimeValidation: boolean;
+}

package/dist/types/api-arguments.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api-bindings.d.ts

@@ -0,0 +1,34 @@
+import type { ApiOperationContract } from './api-operation.js';
+import type { OutputBinding } from './api-arguments.js';
+import type { JsonObject } from './openapi.js';
+import type { NativeOutputContract } from './node-output.js';
+export interface ApiBindingMaterial {
+    callId: string;
+    operation: ApiOperationContract;
+    requestMediaType?: string;
+}
+export interface PlannedApiBindings {
+    callId: string;
+    bindings: OutputBinding[];
+}
+export interface ApiBindingPlan {
+    calls: PlannedApiBindings[];
+    gaps: ApiBindingGap[];
+}
+export interface ApiBindingGap {
+    callId: string;
+    targetPointer: string;
+    description: string;
+}
+export interface ValidateApiBindingAssignmentsInput {
+    calls: PlannedApiBindings[];
+    materials: ApiBindingMaterial[];
+    nativeOutputs?: NativeOutputContract[];
+}
+export interface ValidateApiBindingPlanInput {
+    plan: ApiBindingPlan;
+    materials: ApiBindingMaterial[];
+    nativeOutputs?: NativeOutputContract[];
+}
+export type BindingSchema = JsonObject | boolean;
+export type RequestContainerKind = 'array' | 'object';

package/dist/types/api-bindings.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api-catalog.d.ts

@@ -0,0 +1,34 @@
+import type { OpenApiDocument, OperationCandidate } from './openapi.js';
+export interface ApiSource {
+    id: string;
+    spec: OpenApiDocument;
+}
+export interface ApiOperationKey {
+    documentId: string;
+    snapshotId: string;
+    operationRef: string;
+}
+export interface ApiOperationCandidate extends OperationCandidate {
+    key: ApiOperationKey;
+}
+export interface ApiCatalogDocument extends ApiSource {
+    snapshotId: string;
+}
+export interface ApiCatalog {
+    documents: ApiCatalogDocument[];
+    operations: ApiOperationCandidate[];
+}
+/** One scenario call instance; separate roles may reference the same operation key. */
+export interface SelectedApiOperation {
+    key: ApiOperationKey;
+    purpose: string;
+}
+export interface ApiCapabilityGap {
+    kind: 'missing_operation' | 'insufficient_contract';
+    description: string;
+    operation?: ApiOperationKey;
+}
+export interface ApiSelection {
+    operations: SelectedApiOperation[];
+    gaps: ApiCapabilityGap[];
+}

package/dist/types/api-catalog.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api-operation.d.ts

@@ -0,0 +1,26 @@
+import type { OperationObject as Operation30, ParameterObject as Parameter30, PathItemObject as PathItem30, ServerObject as Server30 } from '@scalar/openapi-types/3.0';
+import type { OperationObject as Operation31, ParameterObject as Parameter31, PathItemObject as PathItem31, ServerObject as Server31 } from '@scalar/openapi-types/3.1';
+import type { OperationObject as Operation32, ParameterObject as Parameter32, PathItemObject as PathItem32, ServerObject as Server32 } from '@scalar/openapi-types/3.2';
+import type { ApiOperationKey } from './api-catalog.js';
+import type { JsonObject } from './openapi.js';
+export type ApiOperationObject = Operation30 | Operation31 | Operation32;
+export type ApiParameterObject = Parameter30 | Parameter31 | Parameter32;
+export type ApiPathItemObject = PathItem30 | PathItem31 | PathItem32;
+export type ApiServerObject = Server30 | Server31 | Server32;
+export type ApiSecurityRequirement = Record<string, string[]>;
+export interface EffectiveApiContract {
+    parameters: ApiParameterObject[];
+    security: ApiSecurityRequirement[];
+    securitySchemes: JsonObject;
+    servers?: ApiServerObject[];
+}
+export interface ApiOperationContract {
+    key: ApiOperationKey;
+    openapiVersion: string;
+    source: 'paths';
+    method: string;
+    path: string;
+    operation: ApiOperationObject;
+    pathItem: ApiPathItemObject;
+    effective: EffectiveApiContract;
+}

package/dist/types/api-operation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api-response-pointers.d.ts

@@ -0,0 +1,20 @@
+export type ApiResponsePointerType = string | string[];
+export interface ApiResponsePointer {
+    pointer: string;
+    schemaLocation: string;
+    type?: ApiResponsePointerType;
+    description?: string;
+}
+export type ApiResponsePointerBoundaryKind = 'additional-properties' | 'pattern-properties' | 'array-items' | 'reference' | 'recursive-schema' | 'unconstrained';
+export interface ApiResponsePointerBoundary {
+    pointer: string;
+    schemaLocation: string;
+    kind: ApiResponsePointerBoundaryKind;
+    constraint?: string;
+}
+export interface ApiResponsePointerCatalog {
+    responseKey: string;
+    mediaType: string;
+    declaredPointers: ApiResponsePointer[];
+    dynamicLocations: ApiResponsePointerBoundary[];
+}

package/dist/types/api-response-pointers.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api-response.d.ts

@@ -0,0 +1,14 @@
+import type { ApiOperationContract } from './api-operation.js';
+export interface ApiResponseValidationInput {
+    operation: ApiOperationContract;
+}
+export interface ApiResponseEnvelope {
+    statusCode: number;
+    headers: Record<string, unknown>;
+    body?: unknown;
+}
+export interface ApiResponseValidationValue {
+    statusCode: number;
+    mediaType?: string;
+    body?: unknown;
+}

package/dist/types/api-response.js

@@ -0,0 +1 @@
+export {};

package/dist/types/array-projection.d.ts

@@ -0,0 +1,5 @@
+import type { BindingSchema } from './api-bindings.js';
+export interface ArrayItemProjection {
+    allowsArray: boolean;
+    schema: BindingSchema;
+}

package/dist/types/array-projection.js

@@ -0,0 +1 @@
+export {};

package/dist/types/catalog.d.ts

@@ -0,0 +1,17 @@
+import type { OpenApiDocument, OperationCandidate, ParsedDocument } from './openapi.js';
+export interface CatalogSource {
+    id: string;
+    spec: OpenApiDocument;
+}
+export interface CatalogEntry {
+    id: string;
+    candidate: OperationCandidate;
+}
+export interface ParsedCatalogSource extends CatalogSource {
+    document: ParsedDocument;
+    operations: OperationCandidate[];
+}
+export interface OperationCatalog {
+    sources: Map<string, ParsedCatalogSource>;
+    entries: CatalogEntry[];
+}

package/dist/types/catalog.js

@@ -0,0 +1 @@
+export {};

package/dist/types/inbound.d.ts

@@ -0,0 +1,18 @@
+import type { JsonObject, OperationCandidate } from './openapi.js';
+export interface WebhookOperationCandidate extends OperationCandidate {
+    source: 'webhooks';
+}
+export interface CallbackOperationCandidate extends OperationCandidate {
+    source: 'callbacks';
+    parentOperationRef: string;
+}
+export type InboundOperationCandidate = WebhookOperationCandidate | CallbackOperationCandidate;
+export interface WebhookOperationSource {
+    candidate: WebhookOperationCandidate;
+    operation: JsonObject;
+}
+export interface CallbackOperationSource {
+    candidate: CallbackOperationCandidate;
+    operation: JsonObject;
+}
+export type InboundOperationSource = WebhookOperationSource | CallbackOperationSource;

package/dist/types/inbound.js

@@ -0,0 +1 @@
+export {};

package/dist/types/legacy-plan.d.ts

@@ -0,0 +1,47 @@
+export type ExpectedBody = Record<string, unknown>;
+export type WorkflowInputs = Record<string, unknown>;
+export type InputValues = Record<string, unknown>;
+export interface WorkflowPlan {
+    version: '1';
+    goal: string;
+    operationRef: string;
+    inputs?: WorkflowInputs;
+    requestMediaType?: string;
+    expectedBody?: ExpectedBody;
+}
+export interface ResponseReference {
+    fromStep: string;
+    field: string;
+}
+export interface SequenceStep {
+    id: string;
+    operationRef: string;
+    inputs?: Record<string, unknown>;
+    requestMediaType?: string;
+    expectedBody?: ExpectedBody;
+}
+export interface SequencePlan {
+    version: '1';
+    goal: string;
+    steps: SequenceStep[];
+}
+export interface CatalogStep extends SequenceStep {
+    documentId: string;
+}
+export interface CapabilityGap {
+    kind: 'missing_operation' | 'insufficient_contract';
+    description: string;
+    documentId?: string;
+    operationRef?: string;
+}
+export interface CatalogSequencePlan extends Omit<SequencePlan, 'steps'> {
+    steps: CatalogStep[];
+    gaps?: CapabilityGap[];
+}
+export interface CatalogDiagnostic {
+    code: 'missing_operation' | 'insufficient_contract' | 'missing_input' | 'effect_not_approved';
+    message: string;
+    stepId?: string;
+    documentId?: string;
+    operationRef?: string;
+}

package/dist/types/legacy-plan.js

@@ -0,0 +1 @@
+export {};

package/dist/types/node-output.d.ts

@@ -0,0 +1,11 @@
+import type { BindingSchema } from './api-bindings.js';
+import type { PlannedNativeNode, WorkflowCapability } from './workflow-plan.js';
+/** A native node's JSON item contract, not an HTTP response envelope. */
+export interface NativeOutputContract {
+    nodeId: string;
+    schema: BindingSchema;
+}
+export interface CreateNativeOutputContractsInput {
+    nativeNodes: PlannedNativeNode[];
+    capabilities: WorkflowCapability[];
+}

package/dist/types/node-output.js

@@ -0,0 +1 @@
+export {};

package/dist/types/oas-value-validation.d.ts

@@ -0,0 +1,8 @@
+import type { createValidator } from '@scalar/json-schema-validator';
+import type { JsonObject } from './openapi.js';
+export type OasValueSchema = JsonObject | boolean;
+export type OasValueValidation = ReturnType<typeof createValidator>;
+export interface OasValueValidator {
+    schema: JsonObject;
+    validate: OasValueValidation;
+}

package/dist/types/oas-value-validation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/openapi.d.ts

@@ -1,6 +1,11 @@
+import type { Document as OpenApi30Document } from '@scalar/openapi-types/3.0';
+import type { Document as OpenApi31Document } from '@scalar/openapi-types/3.1';
+import type { Document as OpenApi32Document } from '@scalar/openapi-types/3.2';
+export type OpenApiDocument = OpenApi30Document | OpenApi31Document | OpenApi32Document;
 export type JsonObject = Record<string, unknown>;
 export type Scalar = string | number | boolean;
 export type OperationMethod = string;
+export type OperationSourceKind = 'paths' | 'webhooks' | 'callbacks';
 export interface OperationEntry {
     method: string;
     key: string;
@@ -10,38 +15,17 @@ export interface ScalarSchema {
     type: string;
     enum?: Scalar[];
 }
-export type ScalarProperties = Record<string, ScalarSchema>;
-export interface OperationParameter {
-    name: string;
-    in: 'path' | 'query';
-    required: boolean;
-    schema: ScalarSchema;
-}
-export interface OperationBody {
-    required: boolean;
-    requiredProperties: string[];
-    properties: ScalarProperties;
-}
 export interface OperationMetadata {
     operationId?: string;
     summary: string;
     description: string;
     tags: string[];
 }
-export interface Operation extends OperationMetadata {
+export interface OperationCandidate extends OperationMetadata {
+    source: OperationSourceKind;
     operationRef: string;
     method: OperationMethod;
     path: string;
-    effect: 'read' | 'write' | 'unknown';
-    status: number;
-    parameters: OperationParameter[];
-    body?: OperationBody;
-    responseProperties: ScalarProperties;
-}
-export type OperationCandidate = Pick<Operation, 'operationRef' | 'operationId' | 'method' | 'path' | 'summary' | 'description' | 'tags'>;
-export interface ObjectSchemaProperties {
-    properties: JsonObject;
-    required: string[];
 }
 export interface ParsedDocument {
     spec: JsonObject;

package/dist/types/request.d.ts

@@ -0,0 +1,41 @@
+import type { JsonObject, OperationCandidate, OperationEntry, OperationMetadata, OperationMethod } from './openapi.js';
+export interface OperationSource {
+    candidate: OperationCandidate;
+    pathItem: JsonObject;
+    entry: OperationEntry;
+}
+export type ResponseProperties = Record<string, JsonObject | boolean>;
+export type OperationResponses = Record<string, ResponseProperties>;
+export interface OperationParameter {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    required: boolean;
+    schema: JsonObject | boolean;
+    style: string;
+    explode: boolean;
+    allowReserved: boolean;
+    contentMediaType?: string;
+}
+export interface OperationBody {
+    required: boolean;
+    mediaTypes: Record<string, OperationBodyMedia>;
+}
+export interface OperationBodyMedia {
+    schema?: JsonObject | boolean;
+    properties: JsonObject;
+    encoding?: JsonObject;
+}
+export interface OperationAuthentication {
+    schemeName: string;
+    credentialType: 'httpBearerAuth';
+}
+export interface Operation extends OperationMetadata {
+    source: 'paths';
+    operationRef: string;
+    method: OperationMethod;
+    path: string;
+    authentication?: OperationAuthentication;
+    parameters: OperationParameter[];
+    body?: OperationBody;
+    responses: OperationResponses;
+}

package/dist/types/request.js

@@ -0,0 +1 @@
+export {};

package/dist/types/reviewable-workflow.d.ts

@@ -0,0 +1,53 @@
+import type { ApiOperationContract } from './api-operation.js';
+import type { ApiOperationKey } from './api-catalog.js';
+import type { OutputBinding } from './api-arguments.js';
+import type { WorkflowApiMaterial, WorkflowCapability, WorkflowGraphPlan, PlannedNativeNode, WorkflowPlanEdge } from './workflow-plan.js';
+export interface WorkflowReviewGap {
+    id: string;
+    stage: 'api-selection' | 'api-bindings' | 'workflow-graph';
+    description: string;
+    operation?: ApiOperationKey;
+    callId?: string;
+    targetPointer?: string;
+}
+export interface ReadyWorkflowApiMaterial extends WorkflowApiMaterial {
+    status: 'ready';
+}
+export interface BlockedWorkflowApiMaterial {
+    status: 'blocked';
+    callId: string;
+    operation: ApiOperationContract;
+    requestMediaType?: string;
+    bindings: OutputBinding[];
+    gapIds: string[];
+}
+export type ReviewableWorkflowApiMaterial = ReadyWorkflowApiMaterial | BlockedWorkflowApiMaterial;
+export interface BlockedWorkflowCall {
+    callId: string;
+    gapIds: string[];
+}
+export interface ProposedWorkflowGap {
+    id: string;
+    description: string;
+}
+export interface ReviewableWorkflowGraphProposal {
+    nativeNodes: PlannedNativeNode[];
+    edges: WorkflowPlanEdge[];
+    additionalGaps: ProposedWorkflowGap[];
+    blockedCalls: BlockedWorkflowCall[];
+}
+export interface ReviewableWorkflowGraphPlan extends WorkflowGraphPlan {
+    gaps: WorkflowReviewGap[];
+    blockedCalls: BlockedWorkflowCall[];
+}
+export interface ReviewableWorkflowPlanningContext {
+    materials: ReviewableWorkflowApiMaterial[];
+    capabilities: WorkflowCapability[];
+}
+export interface CreateReviewableWorkflowGraphPlanInput extends ReviewableWorkflowPlanningContext {
+    gaps: WorkflowReviewGap[];
+    proposal: ReviewableWorkflowGraphProposal;
+}
+export interface ValidateReviewableWorkflowGraphPlanInput extends ReviewableWorkflowPlanningContext {
+    plan: ReviewableWorkflowGraphPlan;
+}

package/dist/types/reviewable-workflow.js

@@ -0,0 +1 @@
+export {};

package/dist/types/schema-dialect.d.ts

@@ -0,0 +1 @@
+export type SchemaDialect = 'openapi-3.0' | 'draft-2020-12';

package/dist/types/schema-dialect.js

@@ -0,0 +1 @@
+export {};

package/dist/types/schema-json.d.ts

@@ -0,0 +1,4 @@
+export type SchemaJsonValue = null | boolean | number | string | SchemaJsonValue[] | SchemaJsonObject;
+export interface SchemaJsonObject {
+    [key: string]: SchemaJsonValue;
+}

package/dist/types/schema-json.js

@@ -0,0 +1 @@
+export {};

package/dist/types/schema-resource.d.ts

@@ -0,0 +1,12 @@
+import type { BindingSchema } from './api-bindings.js';
+export type SchemaDeclaredType = string | string[] | undefined;
+export interface SchemaResourceLocation {
+    reference: string;
+    baseUri: string;
+}
+export interface SchemaResourceContext {
+    root: BindingSchema;
+    reference: (schema: BindingSchema) => BindingSchema;
+    resolve: (schema: BindingSchema) => BindingSchema;
+    bundle: (projection: BindingSchema) => BindingSchema;
+}

package/dist/types/schema-resource.js

@@ -0,0 +1 @@
+export {};