@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/parameters-unique.js

@@ -0,0 +1,27 @@
+export const ParametersUnique = () => {
+    return {
+        Parameters: {
+            enter(parameters, { report, location }) {
+                if (!parameters)
+                    return;
+                const seenParameters = new Set();
+                for (const parameter of parameters) {
+                    if (seenParameters.has(parameter?.name)) {
+                        report({
+                            message: 'The parameter `name` must be unique amongst listed parameters.',
+                            location: location.child([parameters.indexOf(parameter)]),
+                        });
+                    }
+                    if (seenParameters.has(parameter?.reference)) {
+                        report({
+                            message: 'The parameter `reference` must be unique amongst listed parameters.',
+                            location: location.child([parameters.indexOf(parameter)]),
+                        });
+                    }
+                    seenParameters.add(parameter?.name ?? parameter?.reference);
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=parameters-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/requestBody-replacements-unique.js

@@ -0,0 +1,30 @@
+export const RequestBodyReplacementsUnique = () => {
+    const seenReplacements = new Set();
+    return {
+        Step: {
+            leave() {
+                seenReplacements.clear();
+            },
+            RequestBody: {
+                enter(requestBody, { report, location }) {
+                    if (!requestBody.replacements)
+                        return;
+                    for (const replacement of requestBody.replacements) {
+                        if (seenReplacements.has(replacement.target)) {
+                            report({
+                                message: 'Every `replacement` in `requestBody` must be unique.',
+                                location: location.child([
+                                    'replacements',
+                                    requestBody.replacements.indexOf(replacement),
+                                    `target`,
+                                ]),
+                            });
+                        }
+                        seenReplacements.add(replacement.target);
+                    }
+                },
+            },
+        },
+    };
+};
+//# sourceMappingURL=requestBody-replacements-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/sourceDescription-type.js

@@ -0,0 +1,19 @@
+export const SourceDescriptionType = () => {
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions, { report, location }) {
+                if (!sourceDescriptions.length)
+                    return;
+                for (const sourceDescription of sourceDescriptions) {
+                    if (!['openapi', 'arazzo'].includes(sourceDescription?.type)) {
+                        report({
+                            message: 'The `type` property of the `sourceDescription` object must be either `openapi` or `arazzo`.',
+                            location: location.child([sourceDescriptions.indexOf(sourceDescription)]),
+                        });
+                    }
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=sourceDescription-type.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/sourceDescriptions-name-unique.js

@@ -0,0 +1,21 @@
+export const SourceDescriptionsNameUnique = () => {
+    const seenSourceDescriptions = new Set();
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions, { report, location }) {
+                if (!sourceDescriptions.length)
+                    return;
+                for (const sourceDescription of sourceDescriptions) {
+                    if (seenSourceDescriptions.has(sourceDescription.name)) {
+                        report({
+                            message: 'The `name` must be unique amongst all SourceDescriptions.',
+                            location: location.child([sourceDescriptions.indexOf(sourceDescription)]),
+                        });
+                    }
+                    seenSourceDescriptions.add(sourceDescription.name);
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=sourceDescriptions-name-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/sourceDescriptions-not-empty.js

@@ -0,0 +1,15 @@
+export const SourceDescriptionsNotEmpty = () => {
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions, { report, location }) {
+                if (!sourceDescriptions?.length) {
+                    report({
+                        message: 'The `sourceDescriptions` list must have at least one entry.',
+                        location,
+                    });
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=sourceDescriptions-not-empty.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/step-onFailure-unique.js

@@ -0,0 +1,27 @@
+export const StepOnFailureUnique = () => {
+    return {
+        OnFailureActionList: {
+            enter(onFailureActionList, { report, location }) {
+                if (!onFailureActionList)
+                    return;
+                const seenFailureActions = new Set();
+                for (const onFailureAction of onFailureActionList) {
+                    if (seenFailureActions.has(onFailureAction?.name)) {
+                        report({
+                            message: 'The action `name` must be unique amongst listed `onFailure` actions.',
+                            location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+                        });
+                    }
+                    if (seenFailureActions.has(onFailureAction?.reference)) {
+                        report({
+                            message: 'The action `reference` must be unique amongst listed `onFailure` actions.',
+                            location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+                        });
+                    }
+                    seenFailureActions.add(onFailureAction.name ?? onFailureAction.reference);
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=step-onFailure-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/step-onSuccess-unique.js

@@ -0,0 +1,27 @@
+export const StepOnSuccessUnique = () => {
+    return {
+        OnSuccessActionList: {
+            enter(onSuccessActionList, { report, location }) {
+                if (!onSuccessActionList)
+                    return;
+                const seenSuccessActions = new Set();
+                for (const onSuccessAction of onSuccessActionList) {
+                    if (seenSuccessActions.has(onSuccessAction?.name)) {
+                        report({
+                            message: 'The action `name` must be unique amongst listed `onSuccess` actions.',
+                            location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+                        });
+                    }
+                    if (seenSuccessActions.has(onSuccessAction?.reference)) {
+                        report({
+                            message: 'The action `reference` must be unique amongst listed `onSuccess` actions.',
+                            location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+                        });
+                    }
+                    seenSuccessActions.add(onSuccessAction?.name ?? onSuccessAction?.reference);
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=step-onSuccess-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/stepId-unique.js

@@ -0,0 +1,23 @@
+export const StepIdUnique = () => {
+    return {
+        Workflow: {
+            enter(workflow, { report, location }) {
+                if (!workflow.steps)
+                    return;
+                const seenSteps = new Set();
+                for (const step of workflow.steps) {
+                    if (!step.stepId)
+                        return;
+                    if (seenSteps.has(step.stepId)) {
+                        report({
+                            message: 'The `stepId` must be unique amongst all steps described in the workflow.',
+                            location: location.child(['steps', workflow.steps.indexOf(step)]),
+                        });
+                    }
+                    seenSteps.add(step.stepId);
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=stepId-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/workflow-dependsOn.js

@@ -0,0 +1,53 @@
+export const WorkflowDependsOn = () => {
+    const seenWorkflow = new Set();
+    const existingSourceDescriptions = new Set();
+    const existingWorkflowIds = new Set();
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions) {
+                for (const sourceDescription of sourceDescriptions) {
+                    existingSourceDescriptions.add(sourceDescription.name);
+                }
+            },
+        },
+        Workflows: {
+            enter(workflows) {
+                for (const workflow of workflows) {
+                    existingWorkflowIds.add(workflow.workflowId);
+                }
+            },
+        },
+        Workflow: {
+            leave(workflow, { report, location }) {
+                if (!workflow.dependsOn)
+                    return;
+                for (const item of workflow.dependsOn) {
+                    // Possible dependsOn workflow pattern: $sourceDescriptions.<name>.<workflowId>
+                    if (item.startsWith('$sourceDescriptions.')) {
+                        const sourceDescriptionName = item.split('.')[1];
+                        if (!existingSourceDescriptions.has(sourceDescriptionName)) {
+                            report({
+                                message: `SourceDescription ${sourceDescriptionName} must be defined in sourceDescriptions.`,
+                                location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+                            });
+                        }
+                    }
+                    if (!item.startsWith('$sourceDescriptions') && !existingWorkflowIds.has(item)) {
+                        report({
+                            message: `Workflow ${item} must be defined in workflows.`,
+                            location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+                        });
+                    }
+                    if (seenWorkflow.has(item)) {
+                        report({
+                            message: 'Every workflow in dependsOn must be unique.',
+                            location: location.child([`dependsOn`]),
+                        });
+                    }
+                    seenWorkflow.add(item);
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=workflow-dependsOn.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/arazzo/workflowId-unique.js

@@ -0,0 +1,19 @@
+export const WorkflowIdUnique = () => {
+    const seenWorkflow = new Set();
+    return {
+        Workflow: {
+            enter(workflow, { report, location }) {
+                if (!workflow.workflowId)
+                    return;
+                if (seenWorkflow.has(workflow.workflowId)) {
+                    report({
+                        message: 'Every workflow must have a unique `workflowId`.',
+                        location: location.child([workflow.workflowId]),
+                    });
+                }
+                seenWorkflow.add(workflow.workflowId);
+            },
+        },
+    };
+};
+//# sourceMappingURL=workflowId-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/async2/channels-kebab-case.js

@@ -0,0 +1,16 @@
+export const ChannelsKebabCase = () => {
+    return {
+        Channel(_channel, { report, key }) {
+            const segments = key
+                .split(/[/.:]/) // split on / or : as likely channel namespacers
+                .filter((s) => s !== ''); // filter out empty segments
+            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+                report({
+                    message: `\`${key}\` does not use kebab-case.`,
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=channels-kebab-case.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/async2/index.js

@@ -0,0 +1,32 @@
+import { Assertions } from '../common/assertions/index.js';
+import { InfoContact } from '../common/info-contact.js';
+import { InfoLicenseStrict } from '../common/info-license-strict.js';
+import { NoDuplicatedTagNames } from '../common/no-duplicated-tag-names.js';
+import { NoEnumTypeMismatch } from '../common/no-enum-type-mismatch.js';
+import { NoRequiredSchemaPropertiesUndefined } from '../common/no-required-schema-properties-undefined.js';
+import { NoSchemaTypeMismatch } from '../common/no-schema-type-mismatch.js';
+import { NoUnresolvedRefs } from '../common/no-unresolved-refs.js';
+import { OperationOperationId } from '../common/operation-operationId.js';
+import { Struct } from '../common/struct.js';
+import { TagDescription } from '../common/tag-description.js';
+import { TagsAlphabetical } from '../common/tags-alphabetical.js';
+import { ChannelsKebabCase } from './channels-kebab-case.js';
+import { NoChannelTrailingSlash } from './no-channel-trailing-slash.js';
+export const rules = {
+    struct: Struct,
+    'no-unresolved-refs': NoUnresolvedRefs,
+    assertions: Assertions,
+    'info-contact': InfoContact,
+    'info-license-strict': InfoLicenseStrict,
+    'operation-operationId': OperationOperationId,
+    'channels-kebab-case': ChannelsKebabCase,
+    'no-channel-trailing-slash': NoChannelTrailingSlash,
+    'tag-description': TagDescription,
+    'tags-alphabetical': TagsAlphabetical,
+    'no-duplicated-tag-names': NoDuplicatedTagNames,
+    'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined,
+    'no-enum-type-mismatch': NoEnumTypeMismatch,
+    'no-schema-type-mismatch': NoSchemaTypeMismatch,
+};
+export const preprocessors = {};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/async2/no-channel-trailing-slash.js

@@ -0,0 +1,13 @@
+export const NoChannelTrailingSlash = () => {
+    return {
+        Channel(_channel, { report, key, location }) {
+            if (key.endsWith('/') && key !== '/') {
+                report({
+                    message: `\`${key}\` should not have a trailing slash.`,
+                    location: location.key(),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=no-channel-trailing-slash.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/async3/channels-kebab-case.js

@@ -0,0 +1,16 @@
+export const ChannelsKebabCase = () => {
+    return {
+        Channel(channel, { report }) {
+            const segments = (channel.address || '')
+                .split(/[/.:]/) // split on / or : as likely channel namespacers
+                .filter((s) => s !== ''); // filter out empty segments
+            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+                report({
+                    message: `\`${channel.address}\` does not use kebab-case.`,
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=channels-kebab-case.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/async3/index.js

@@ -0,0 +1,32 @@
+import { Assertions } from '../common/assertions/index.js';
+import { InfoContact } from '../common/info-contact.js';
+import { InfoLicenseStrict } from '../common/info-license-strict.js';
+import { NoDuplicatedTagNames } from '../common/no-duplicated-tag-names.js';
+import { NoEnumTypeMismatch } from '../common/no-enum-type-mismatch.js';
+import { NoRequiredSchemaPropertiesUndefined } from '../common/no-required-schema-properties-undefined.js';
+import { NoSchemaTypeMismatch } from '../common/no-schema-type-mismatch.js';
+import { NoUnresolvedRefs } from '../common/no-unresolved-refs.js';
+import { OperationOperationId } from '../common/operation-operationId.js';
+import { Struct } from '../common/struct.js';
+import { TagDescription } from '../common/tag-description.js';
+import { TagsAlphabetical } from '../common/tags-alphabetical.js';
+import { ChannelsKebabCase } from './channels-kebab-case.js';
+import { NoChannelTrailingSlash } from './no-channel-trailing-slash.js';
+export const rules = {
+    struct: Struct,
+    'no-unresolved-refs': NoUnresolvedRefs,
+    assertions: Assertions,
+    'info-contact': InfoContact,
+    'info-license-strict': InfoLicenseStrict,
+    'operation-operationId': OperationOperationId,
+    'channels-kebab-case': ChannelsKebabCase,
+    'no-channel-trailing-slash': NoChannelTrailingSlash,
+    'tag-description': TagDescription,
+    'tags-alphabetical': TagsAlphabetical,
+    'no-duplicated-tag-names': NoDuplicatedTagNames,
+    'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined,
+    'no-enum-type-mismatch': NoEnumTypeMismatch,
+    'no-schema-type-mismatch': NoSchemaTypeMismatch,
+};
+export const preprocessors = {};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/async3/no-channel-trailing-slash.js

@@ -0,0 +1,13 @@
+export const NoChannelTrailingSlash = () => {
+    return {
+        Channel(channel, { report, location }) {
+            if (channel?.address?.endsWith('/') && channel?.address !== '/') {
+                report({
+                    message: `\`${channel.address}\` should not have a trailing slash.`,
+                    location: location.key(),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=no-channel-trailing-slash.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/catalog-entity/entity-key-valid.js

@@ -0,0 +1,39 @@
+import { isPlainObject } from '../../utils/is-plain-object.js';
+const validKeyPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const MIN_KEY_LENGTH = 2;
+const MAX_KEY_LENGTH = 150;
+export const EntityKeyValid = () => {
+    return {
+        any(node, { report, location }) {
+            if (isPlainObject(node) && 'key' in node) {
+                const key = node.key;
+                if (typeof key !== 'string') {
+                    report({
+                        message: 'Entity `key` must be a string.',
+                        location: location.child(['key']),
+                    });
+                    return;
+                }
+                if (key.length < MIN_KEY_LENGTH) {
+                    report({
+                        message: `Entity 'key' must be at least ${MIN_KEY_LENGTH} characters long.`,
+                        location: location.child(['key']),
+                    });
+                }
+                if (key.length > MAX_KEY_LENGTH) {
+                    report({
+                        message: `Entity 'key' must not exceed ${MAX_KEY_LENGTH} characters.`,
+                        location: location.child(['key']),
+                    });
+                }
+                if (!validKeyPattern.test(key)) {
+                    report({
+                        message: 'Entity `key` must contain only lowercase letters, numbers, and hyphens, and cannot start or end with a hyphen.',
+                        location: location.child(['key']),
+                    });
+                }
+            }
+        },
+    };
+};
+//# sourceMappingURL=entity-key-valid.js.map