@devkong/cli 0.0.1

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@devkong/cli",
+  "version": "0.0.1",
+  "type": "commonjs",
+  "main": "./index.js",
+  "typings": "./index.d.ts",
+  "bin": {
+    "kong": "./index.js"
+  }
+}

package/packages/kong-cli/src/commands/configureCommand.d.ts

@@ -0,0 +1,5 @@
+export declare class ConfigureCommand {
+    execute(): Promise<void>;
+    private selectProfile;
+    private configureProfile;
+}

package/packages/kong-cli/src/commands/generateCommand.d.ts

@@ -0,0 +1,3 @@
+export declare class GenerateCommand {
+    execute(extensionName: string, sdk: "kotlin" | "python", presetVersion: string): Promise<void>;
+}

package/packages/kong-cli/src/commands/installCommand.d.ts

@@ -0,0 +1,4 @@
+export declare class InstallCommand {
+    execute(extensionName?: string): Promise<void>;
+    private scriptPath;
+}

package/packages/kong-cli/src/commands/listExtensionSnapshotCommand.d.ts

@@ -0,0 +1,6 @@
+import { Profile } from "../common/profile";
+export declare class ListExtensionSnapshotCommand {
+    private readonly managementClient;
+    constructor(profile: Profile);
+    execute(): Promise<void>;
+}

package/packages/kong-cli/src/commands/publishCommand.d.ts

@@ -0,0 +1,14 @@
+import { Profile } from "../common/profile";
+export declare class PublishCommand {
+    private readonly isWin;
+    private registryClient;
+    private managementClient;
+    private get wslPrefix();
+    constructor(profile: Profile);
+    execute(repoName: string): Promise<void>;
+    private resolveRegistryUrl;
+    private dockerBuildCmdText;
+    private dockerPushCmdText;
+    private dockerLoginCmdText;
+    private getSchemaCmdText;
+}

package/packages/kong-cli/src/commands/setExtensionAliasCommand.d.ts

@@ -0,0 +1,7 @@
+import { Profile } from "../common/profile";
+export declare class SetExtensionAliasCommand {
+    private publicClient;
+    private managementClient;
+    constructor(profile: Profile);
+    execute(aliasName: string, extensionVersion: number): Promise<void>;
+}

package/packages/kong-cli/src/common/cli.d.ts

@@ -0,0 +1,7 @@
+export declare function getPresetVersion(): string;
+export declare function withSpinner<T>(options: {
+    action: () => Promise<T>;
+    startMessage?: string;
+    errorMessage?: string;
+    onSucceeded?: (result: T) => string;
+}): Promise<T>;

package/packages/kong-cli/src/common/kongJson.d.ts

@@ -0,0 +1,10 @@
+import { AppExtension, AppExtensionSnapshotDetails, SdkExtensionAlias } from "@kong/contract";
+import { User } from "@kong/ts";
+export interface KongJson {
+    id: AppExtension["id"];
+    sdk: AppExtensionSnapshotDetails["sdk"];
+    name: AppExtension["name"];
+    ownership: [User["name"], ...Array<User["name"]>];
+    alias?: SdkExtensionAlias;
+}
+export declare function getKongJson(): KongJson;

package/packages/kong-cli/src/common/kongJsonSchema.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema7 } from "json-schema";
+export declare const KONG_JSON_SCHEMA: JSONSchema7;

package/packages/kong-cli/src/common/profile.d.ts

@@ -0,0 +1,9 @@
+import { UrlText } from "@kong/ts";
+export interface Profile {
+    kongBaseUrl: UrlText;
+}
+export type ProfileName = "default" | string;
+export type ConfigProfiles = Record<ProfileName, Profile>;
+export declare function loadProfiles(): ConfigProfiles;
+export declare function saveProfiles(profiles: ConfigProfiles): void;
+export declare function getProfile(profileName?: string): Profile;

package/packages/kong-cli/src/common/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function env(key: string): string;
+export declare function optionalEnv(key: string): string;
+export declare function resolveProjectPath(fileName: string): string;
+export declare function generateShortId(): string;
+export declare function spawnCommand(name: string, commandText: string, inheritStdout?: boolean): Promise<string>;
+export declare function printError(message: string, error: unknown): void;

package/packages/kong-cli/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/packages/kong-cli/src/services/api.d.ts

@@ -0,0 +1,5 @@
+export declare const API_HEADERS: {
+    headers: {
+        "Content-Type": string;
+    };
+};

package/packages/kong-cli/src/services/managementClient.d.ts

@@ -0,0 +1,9 @@
+import { AppExtension, AppExtensionSnapshot, AppExtensionSnapshotDetails } from "@kong/contract";
+import { Optional, UrlText } from "@kong/ts";
+export declare class ManagementClient {
+    private readonly baseUrl;
+    constructor(baseUrl: UrlText);
+    createExtensionSnapshot(extensionId: AppExtension["id"], extensionName: AppExtension["name"], snapshot: Omit<AppExtensionSnapshotDetails, "id">): Promise<void>;
+    getExtensionSnapshot(extensionName: AppExtension["name"], extensionSnapshotVersion: AppExtensionSnapshot["version"]): Promise<Optional<AppExtensionSnapshotDetails>>;
+    getExtensionSnapshotVersions(extensionId: AppExtension["id"]): Promise<AppExtensionSnapshot[]>;
+}

package/packages/kong-cli/src/services/publicClient.d.ts

@@ -0,0 +1,7 @@
+import { AppExtensionAliasDetails } from "@kong/contract";
+import { UrlText } from "@kong/ts";
+export declare class PublicClient {
+    private readonly baseUrl;
+    constructor(baseUrl: UrlText);
+    assignExtensionAlias(alias: Omit<AppExtensionAliasDetails, "id">): Promise<void>;
+}

package/packages/kong-cli/src/services/registryClient.d.ts

@@ -0,0 +1,14 @@
+import { UrlText, User } from "@kong/ts";
+interface PublishDetails {
+    repoName: string;
+    imageName: string;
+    imageVersion: string;
+    userName: User["name"];
+    token: string;
+}
+export declare class RegistryClient {
+    private readonly baseUrl;
+    constructor(baseUrl: UrlText);
+    getPublishDetails(repoName: string): Promise<PublishDetails>;
+}
+export {};

package/packages/kong-spec/src/index.d.ts

@@ -0,0 +1,17 @@
+export { makeServerlessJavaAppProps, serverlessFlowBuilder, stringifyServerlessFlow, } from "./lib/kongServerless";
+export type { FloweyServerlessBuilder } from "./lib/kongServerless";
+export type { KongSpecJobSession } from "./lib/kongSession";
+export type { KongSpecAction, KongSpecActionCallFunction, KongSpecActionCallProcess, KongSpecActionSendEvent, KongSpecAppend, KongSpecBranch, KongSpecCache, KongSpecCallModel, KongSpecCircuitBreaker, KongSpecCondition, KongSpecError, KongSpecEventBroker, KongSpecEventConnection, KongSpecFeatureCompensation, KongSpecFlow, KongSpecFunctionRef, KongSpecHowToInvoke, KongSpecHowToOutput, KongSpecProcessRef, KongSpecRateLimiter, KongSpecRecord, KongSpecRecordHeader, KongSpecRetry, KongSpecState, KongSpecStateCallFunction, KongSpecStateCallProcess, KongSpecStateCompensate, KongSpecStateExit, KongSpecStateFail, KongSpecStateForeach, KongSpecStateInject, KongSpecStateParallel, KongSpecStateSendEvent, KongSpecStateStart, KongSpecStateSucceed, KongSpecStateSwitch, KongSpecStateWaitEvent, KongSpecSupportsActions, KongSpecSupportsErrors, KongSpecSupportsTransition, } from "./lib/kongSpec";
+export { KongSpecBuild } from "./lib/kongSpecBuild";
+export { KongSpecDoc } from "./lib/kongSpecDoc";
+export { KongSpecEnv } from "./lib/kongSpecEnv";
+export type { KongSpecFile } from "./lib/kongSpecFile";
+export type { KongSpecLayout, KongSpecLayoutPosition, KongSpecLayoutPositionKey, } from "./lib/kongSpecLayout";
+export { nameGenerator } from "./lib/kongSpecName";
+export { normalizeName } from "./lib/kongSpecNormalize";
+export { KongSpecRef } from "./lib/kongSpecRef";
+export type { KongSpecActionPath, KongSpecStatePath } from "./lib/kongSpecRef";
+export { convertSpecToServerless } from "./lib/kongSpecToServerless";
+export { findSourceState, getActions, outputAggregator, traverseFlowUp } from "./lib/kongSpecUtils";
+export { validate } from "./lib/kongSpecValidate";
+export type { KongSpecValidationIssue, KongSpecValidators } from "./lib/kongSpecValidate";

package/packages/kong-spec/src/lib/kongServerless.d.ts

@@ -0,0 +1,11 @@
+import { Specification, workflowBuilder } from "@severlessworkflow/sdk-typescript";
+export type FloweyServerlessBuilder = ReturnType<typeof workflowBuilder>;
+export declare function serverlessFlowBuilder(): FloweyServerlessBuilder;
+export declare const copyServerlessFlow: (workflow: Specification.Workflow) => Specification.Workflow;
+export declare function stringifyServerlessFlow(workflow: Specification.Workflow): string;
+interface ServerlessJavaAppPropsGenerator {
+    processId: string;
+    events: Specification.Eventdef[];
+}
+export declare function makeServerlessJavaAppProps({ processId, events }: ServerlessJavaAppPropsGenerator): string;
+export {};

package/packages/kong-spec/src/lib/kongSession.d.ts

@@ -0,0 +1,31 @@
+import { BusinessKey, Distinct, UtcDateTime } from "@kong/ts";
+export declare enum KongSpecSessionAgent {
+    JOB = "JOB"
+}
+interface KongSpecSession {
+    agent: KongSpecSessionAgent;
+    id: Distinct<number, "KongSpecSessionId">;
+    businessKey: BusinessKey;
+    deadline: UtcDateTime;
+    created: UtcDateTime;
+}
+export declare enum KongSpecJobSessionExecutionMode {
+    ASYNC = "ASYNC",
+    SYNC = "SYNC"
+}
+export declare enum KongSpecJobSessionPriority {
+    HIGHEST = "HIGHEST",
+    HIGH = "HIGH",
+    MEDIUM = "MEDIUM",
+    LOW = "LOW",
+    LOWEST = "LOWEST"
+}
+export interface KongSpecJobSession extends KongSpecSession {
+    source: string;
+    namespace: string;
+    topic: string;
+    partition: number;
+    priority: KongSpecJobSessionPriority;
+    executionMode: KongSpecJobSessionExecutionMode;
+}
+export {};

package/packages/kong-spec/src/lib/kongSpec.d.ts

@@ -0,0 +1,199 @@
+import { Distinct, Duration8601, JqFilter, JqObject, JqText, JsonArray, JsonObject, Optional, ShortUUID } from "@kong/ts";
+import { JSONSchema7 } from "json-schema";
+export type KongSpecFunctionRef = Distinct<string, "KongSpecFunctionRef">;
+export type KongSpecProcessRef = Distinct<string, "KongSpecProcessRef">;
+export type KongSpecAppend = "list" | "last";
+interface KongSpecStateBase {
+    id: Distinct<string, "KongSpecStateId">;
+    name: string;
+    type: "start" | "succeed" | "fail" | "inject" | "compensate" | "foreach" | "callFunction" | "parallel" | "switch" | "sendEvent" | "waitEvent" | "callProcess";
+}
+export interface KongSpecSupportsTransition {
+    next: KongSpecStateBase["id"] | null;
+}
+export interface KongSpecError extends KongSpecSupportsTransition {
+    id: Distinct<string, "KongSpecErrorId">;
+    description: string;
+    code: string;
+}
+export interface KongSpecCache {
+    enabled: boolean;
+    key: JqFilter;
+    ttl: Duration8601;
+    onFailure: "RETRY" | "SKIP";
+}
+export interface KongSpecRetry {
+    maxAttempts: number;
+    attemptDelay: Duration8601;
+    attemptTimeout: Duration8601;
+}
+export interface KongSpecCircuitBreaker {
+    enabled: boolean;
+    delay: Duration8601;
+    requestVolumeThreshold: number;
+    failureRatio: number;
+    successThreshold: number;
+}
+export interface KongSpecRateLimiter {
+    enabled: boolean;
+    value: number;
+    window: Duration8601;
+    minSpacing: Duration8601;
+}
+export interface KongSpecHowToInvoke {
+    prefix: string;
+    retry: KongSpecRetry;
+    cache: KongSpecCache;
+    circuitBreaker: KongSpecCircuitBreaker;
+    rateLimiter: KongSpecRateLimiter;
+}
+export interface KongSpecSupportsInvoke {
+    invoke: KongSpecHowToInvoke;
+}
+export interface KongSpecSupportsInput {
+    inputPayload: JqObject;
+}
+export interface KongSpecEffectProducer {
+    id: string;
+    type: string;
+}
+export interface KongSpecEffectAck {
+    producer: KongSpecEffectProducer;
+    seqNum: number;
+}
+export interface KongSpecHowToOutput {
+    ack: KongSpecEffectAck;
+    filter: JqFilter;
+    destinations: string[];
+}
+export interface KongSpecSupportsOutputFilter {
+    outputFilter: JqFilter;
+}
+export interface KongSpecSupportsOutputAppend {
+    outputAppend: Array<KongSpecAppend>;
+}
+export interface KongSpecSupportsOutputSample {
+    outputSample: Optional<JsonObject | JsonArray>;
+}
+export interface KongSpecCallModel extends KongSpecSupportsInput, KongSpecSupportsOutputFilter, KongSpecSupportsOutputAppend, KongSpecSupportsOutputSample, KongSpecSupportsInvoke {
+}
+export interface KongSpecSupportsErrors {
+    errors: KongSpecError[];
+}
+export interface KongSpecSupportsTimeout {
+    timeout: Duration8601;
+}
+export interface KongSpecSupportsCompensatedBy {
+    compensatedBy: KongSpecStateBase["id"] | null;
+}
+export interface KongSpecFeatureCompensation {
+    featureCompensation: "on" | "off";
+}
+export interface KongSpecCanBeUsedForCompensation {
+    usedForCompensation: boolean;
+}
+export interface KongSpecStateStart extends KongSpecStateBase, KongSpecSupportsTransition, KongSpecSupportsTimeout {
+    type: "start";
+    inputSchema: JSONSchema7;
+    inputSample: JsonObject;
+}
+export interface KongSpecStateSucceed extends KongSpecStateBase, KongSpecSupportsOutputFilter {
+    type: "succeed";
+}
+export interface KongSpecStateFail extends KongSpecStateBase, KongSpecSupportsOutputFilter {
+    type: "fail";
+}
+export interface KongSpecStateInject extends KongSpecStateBase, KongSpecSupportsOutputFilter, KongSpecSupportsOutputAppend, KongSpecSupportsTransition {
+    type: "inject";
+}
+export interface KongSpecStateCompensate extends KongSpecStateBase, KongSpecSupportsTransition {
+    type: "compensate";
+}
+export interface KongSpecCondition extends KongSpecSupportsTransition, KongSpecSupportsTransition {
+    id: Distinct<string, "KongSpecConditionId">;
+    match: JqFilter;
+}
+export interface KongSpecStateSwitch extends KongSpecStateBase, KongSpecCanBeUsedForCompensation, KongSpecSupportsTransition {
+    type: "switch";
+    conditions: KongSpecCondition[];
+}
+export interface KongSpecEventBroker {
+    host: string;
+    port: number;
+}
+export interface KongSpecEventConnection {
+    brokers: KongSpecEventBroker[];
+    topic: string;
+    securityProtocol: "PLAINTEXT" | "SSL";
+}
+export interface KongSpecRecordHeader extends JqObject {
+    key: JqText;
+    value: JqText;
+}
+export interface KongSpecRecord extends JqObject {
+    headers: KongSpecRecordHeader[];
+    key: JqText;
+    value: JqText;
+}
+export interface KongSpecStateSendEvent extends KongSpecStateBase, KongSpecSupportsTransition, KongSpecCanBeUsedForCompensation, KongSpecSupportsErrors, KongSpecFeatureCompensation, KongSpecSupportsCompensatedBy {
+    type: "sendEvent";
+    connection: KongSpecEventConnection;
+    record: KongSpecRecord;
+}
+export interface KongSpecStateWaitEvent extends KongSpecStateBase, KongSpecSupportsTransition, KongSpecSupportsErrors, KongSpecFeatureCompensation, KongSpecSupportsTimeout, KongSpecSupportsCompensatedBy, KongSpecSupportsOutputFilter, KongSpecSupportsOutputAppend, KongSpecSupportsOutputSample {
+    type: "waitEvent";
+    connection: KongSpecEventConnection;
+}
+export interface KongSpecStateCallProcess extends KongSpecStateBase, KongSpecSupportsTransition, KongSpecCanBeUsedForCompensation, KongSpecSupportsErrors, KongSpecFeatureCompensation, KongSpecSupportsCompensatedBy, KongSpecCallModel {
+    type: "callProcess";
+    ref: KongSpecProcessRef;
+}
+export interface KongSpecStateCallFunction extends KongSpecStateBase, KongSpecSupportsTransition, KongSpecSupportsErrors, KongSpecFeatureCompensation, KongSpecCanBeUsedForCompensation, KongSpecSupportsCompensatedBy, KongSpecCallModel {
+    type: "callFunction";
+    ref: KongSpecFunctionRef;
+}
+export interface KongSpecActionBase {
+    id: Distinct<string, "KongSpecActionId">;
+    type: "callFunction" | "sendEvent" | "callProcess";
+    name: string;
+}
+export interface KongSpecActionCallFunction extends KongSpecActionBase, KongSpecCallModel {
+    type: "callFunction";
+    ref: KongSpecFunctionRef;
+}
+export interface KongSpecActionCallProcess extends KongSpecActionBase, KongSpecCallModel {
+    type: "callProcess";
+}
+export interface KongSpecActionSendEvent extends KongSpecActionBase {
+    type: "sendEvent";
+    connection: KongSpecEventConnection;
+    record: KongSpecRecord;
+}
+export type KongSpecAction = KongSpecActionCallFunction | KongSpecActionCallProcess | KongSpecActionSendEvent;
+export interface KongSpecSupportsActions {
+    actions: KongSpecAction[];
+}
+export interface KongSpecBranch {
+    id: Distinct<string, "KongSpecBranchId">;
+    actions: KongSpecAction[];
+}
+export interface KongSpecStateForeach extends KongSpecStateBase, KongSpecSupportsTransition, KongSpecCanBeUsedForCompensation, KongSpecFeatureCompensation, KongSpecSupportsCompensatedBy, KongSpecSupportsErrors {
+    type: "foreach";
+    inputCollection: JqFilter;
+    iterationParam: JqFilter;
+    outputCollection: JqFilter;
+    actions: KongSpecAction[];
+}
+export interface KongSpecStateParallel extends KongSpecStateBase, KongSpecSupportsTransition, KongSpecCanBeUsedForCompensation, KongSpecFeatureCompensation, KongSpecSupportsCompensatedBy, KongSpecSupportsErrors {
+    type: "parallel";
+    branches: KongSpecBranch[];
+    completionType: "allOf" | "atLeast";
+}
+export type KongSpecState = KongSpecStateStart | KongSpecStateSucceed | KongSpecStateFail | KongSpecStateInject | KongSpecStateCompensate | KongSpecStateForeach | KongSpecStateCallFunction | KongSpecStateCallProcess | KongSpecStateSwitch | KongSpecStateSendEvent | KongSpecStateWaitEvent | KongSpecStateParallel;
+export type KongSpecStateExit = KongSpecStateFail | KongSpecStateSucceed;
+export interface KongSpecFlow {
+    id: Distinct<ShortUUID, "KongSpecFlowId">;
+    version: "1.0";
+    states: KongSpecState[];
+}
+export {};

package/packages/kong-spec/src/lib/kongSpecBuild.d.ts

@@ -0,0 +1,38 @@
+import { Duration8601, JqObject, Timezone } from "@kong/ts";
+import { KongSpecJobSession } from "./kongSession";
+import { KongSpecActionCallFunction, KongSpecActionSendEvent, KongSpecBranch, KongSpecCallModel, KongSpecCondition, KongSpecError, KongSpecEventBroker, KongSpecFlow, KongSpecFunctionRef, KongSpecHowToInvoke, KongSpecHowToOutput, KongSpecProcessRef, KongSpecRecordHeader, KongSpecStateCallFunction, KongSpecStateCallProcess, KongSpecStateCompensate, KongSpecStateFail, KongSpecStateForeach, KongSpecStateInject, KongSpecStateParallel, KongSpecStateSendEvent, KongSpecStateStart, KongSpecStateSucceed, KongSpecStateSwitch, KongSpecStateWaitEvent } from "./kongSpec";
+export declare class KongSpecBuild {
+    flow(id: KongSpecFlow["id"]): KongSpecFlow;
+    startState(overrides?: Partial<KongSpecStateStart>): KongSpecStateStart;
+    foreachState(overrides?: Partial<KongSpecStateForeach>): KongSpecStateForeach;
+    parallelState(overrides?: Partial<KongSpecStateParallel>): KongSpecStateParallel;
+    callFunctionState(ref: KongSpecFunctionRef, overrides?: Partial<KongSpecStateCallFunction>): KongSpecStateCallFunction;
+    callFunctionAction(ref: KongSpecFunctionRef, overrides?: Partial<KongSpecActionCallFunction>): KongSpecActionCallFunction;
+    callProcessState(ref: KongSpecProcessRef, overrides?: Partial<KongSpecStateCallProcess>): KongSpecStateCallProcess;
+    compensateState(overrides?: Partial<KongSpecStateCompensate>): KongSpecStateCompensate;
+    failState(overrides?: Partial<KongSpecStateFail>): KongSpecStateFail;
+    injectState(overrides?: Partial<KongSpecStateInject>): KongSpecStateInject;
+    succeedState(overrides?: Partial<KongSpecStateSucceed>): KongSpecStateSucceed;
+    sendEventState(overrides?: Partial<KongSpecStateSendEvent>): KongSpecStateSendEvent;
+    sendEventAction(overrides?: Partial<KongSpecActionSendEvent>): KongSpecActionSendEvent;
+    waitEventState(overrides?: Partial<KongSpecStateWaitEvent>): KongSpecStateWaitEvent;
+    switchState(overrides?: Partial<KongSpecStateSwitch>): KongSpecStateSwitch;
+    condition(overrides?: Partial<KongSpecCondition>): KongSpecCondition;
+    branch(id: KongSpecBranch["id"], overrides?: Partial<KongSpecBranch>): KongSpecBranch;
+    broker(overrides?: Partial<KongSpecEventBroker>): KongSpecEventBroker;
+    recordHeader(overrides?: Partial<KongSpecRecordHeader>): KongSpecRecordHeader;
+    error(overrides?: Partial<KongSpecError>): KongSpecError;
+    output(overrides?: Partial<KongSpecHowToOutput>): KongSpecHowToOutput;
+    invoke(overrides?: Partial<KongSpecHowToInvoke>): KongSpecHowToInvoke;
+    retry(overrides?: Partial<KongSpecHowToInvoke["retry"]>): KongSpecHowToInvoke["retry"];
+    circuitBreaker(overrides?: Partial<KongSpecHowToInvoke["circuitBreaker"]>): KongSpecHowToInvoke["circuitBreaker"];
+    rateLimiter(overrides?: Partial<KongSpecHowToInvoke["rateLimiter"]>): {
+        enabled: boolean;
+        value: number;
+        window: Duration8601;
+        minSpacing: Duration8601;
+    };
+    cache(overrides?: Partial<KongSpecHowToInvoke["cache"]>): KongSpecHowToInvoke["cache"];
+    callModel(payload: JqObject): KongSpecCallModel;
+    session(timezone: Timezone, overrides?: Partial<KongSpecJobSession>): KongSpecJobSession;
+}

package/packages/kong-spec/src/lib/kongSpecDoc.d.ts

@@ -0,0 +1,14 @@
+export declare class KongSpecDoc {
+    static aboutCompensation: string;
+    static aboutProcessTimeout: string;
+    static aboutCallbackTimeout: string;
+    static aboutActionDataFilterOfOutput: string;
+    static aboutStateDataFilterOfInput: string;
+    static aboutErrorHandling: string;
+    static aboutCache: string;
+    static aboutRetry: string;
+    static aboutConditions: string;
+    static aboutResilience: string;
+    static aboutLimits: string;
+    static aboutIdentify: string;
+}

package/packages/kong-spec/src/lib/kongSpecEnv.d.ts

@@ -0,0 +1,4 @@
+export declare enum KongSpecEnv {
+    PRODUCTION = "PRODUCTION",
+    DEVELOPMENT = "DEVELOPMENT"
+}

package/packages/kong-spec/src/lib/kongSpecFile.d.ts

@@ -0,0 +1,25 @@
+import { Distinct, Timezone, UrlText, UtcDateTime } from "@kong/ts";
+import { KongSpecFlow } from "./kongSpec";
+import { KongSpecLayout } from "./kongSpecLayout";
+export interface KongSpecFile {
+    version: "1";
+    checkpoint: {
+        id: Distinct<UrlText, "CheckpointId">;
+        documentId: KongSpecFlow["id"];
+        type: "SAVE" | "SNAPSHOT";
+        created: UtcDateTime;
+        createdBy: string;
+    };
+    requestId: {
+        traceId: string;
+        spanId: string;
+    };
+    metadata: {
+        userAgent: string;
+        thumbnail: string;
+        timezone: Timezone;
+        origin: "LOCAL" | "REMOTE";
+    };
+    layout: KongSpecLayout;
+    flow: KongSpecFlow;
+}

package/packages/kong-spec/src/lib/kongSpecLayout.d.ts

@@ -0,0 +1,4 @@
+import { KongSpecAction, KongSpecState } from "./kongSpec";
+export type KongSpecLayoutPositionKey = KongSpecState["id"] | KongSpecAction["id"];
+export type KongSpecLayoutPosition = [number, number];
+export type KongSpecLayout = Record<KongSpecLayoutPositionKey, KongSpecLayoutPosition>;

package/packages/kong-spec/src/lib/kongSpecName.d.ts

@@ -0,0 +1,3 @@
+import { KeyGenerator } from "@kong/ts";
+import { KongSpecFlow } from "./kongSpec";
+export declare function nameGenerator(states: KongSpecFlow["states"]): KeyGenerator;

package/packages/kong-spec/src/lib/kongSpecNormalize.d.ts

@@ -0,0 +1,2 @@
+import { KongSpecAction, KongSpecState } from "./kongSpec";
+export declare function normalizeName(value: KongSpecState["name"] | KongSpecAction["name"]): string;

package/packages/kong-spec/src/lib/kongSpecRef.d.ts

@@ -0,0 +1,16 @@
+import { Optional } from "@kong/ts";
+import { KongSpecAction, KongSpecBranch, KongSpecCondition, KongSpecError, KongSpecState } from "./kongSpec";
+export declare class KongSpecRef {
+    static newStateId(): KongSpecState["id"];
+    static newConditionId(): KongSpecCondition["id"];
+    static newBranchId(): KongSpecBranch["id"];
+    static newErrorId(): KongSpecError["id"];
+    static newActionId(): KongSpecAction["id"];
+}
+export interface KongSpecStatePath {
+    stateRef: KongSpecState["id"];
+}
+export interface KongSpecActionPath extends KongSpecStatePath {
+    branchRef: Optional<KongSpecBranch["id"]>;
+    actionRef: KongSpecAction["id"];
+}

package/packages/kong-spec/src/lib/kongSpecSchema.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema7 } from "json-schema";
+export declare const kongSpecSchema: JSONSchema7;

package/packages/kong-spec/src/lib/kongSpecToServerless.d.ts

@@ -0,0 +1,10 @@
+import { Specification } from "@severlessworkflow/sdk-typescript";
+import { JSONSchema7 } from "json-schema";
+import { KongSpecFlow } from "./kongSpec";
+import { KongSpecEnv } from "./kongSpecEnv";
+interface ConvertSpecToServerlessResult {
+    workflow: Specification.Workflow;
+    inputSchema: JSONSchema7;
+}
+export declare function convertSpecToServerless(type: "main", specFlow: KongSpecFlow, env: KongSpecEnv): ConvertSpecToServerlessResult;
+export {};

package/packages/kong-spec/src/lib/kongSpecUtils.d.ts

@@ -0,0 +1,11 @@
+import { JqFilter, JsonObject } from "@kong/ts";
+import { KongSpecAction, KongSpecFlow, KongSpecState } from "./kongSpec";
+interface FloweyTraverseStateTestItem {
+    id: KongSpecState["id"] | KongSpecAction["id"];
+    source: "initial" | "errors" | "transition" | "conditions" | "compensateBy" | "actions" | "branches";
+}
+export declare function traverseFlowUp(id: KongSpecState["id"] | KongSpecAction["id"], states: KongSpecFlow["states"], test: (current: FloweyTraverseStateTestItem) => boolean): boolean;
+export declare function outputAggregator(jq: (sample: JsonObject, filter: JqFilter) => Promise<string>): (flow: KongSpecFlow, targetRef: KongSpecState["id"] | KongSpecAction["id"], includeTarget?: boolean) => Promise<JsonObject>;
+export declare function getActions(state: KongSpecState): KongSpecAction[];
+export declare function findSourceState(states: KongSpecState[], targetRef: KongSpecState["id"]): import("@kong/ts").Distinct<string, "KongSpecStateId">;
+export {};

package/packages/kong-spec/src/lib/kongSpecValidate.d.ts

@@ -0,0 +1,13 @@
+import { KongSpecAction, KongSpecFlow, KongSpecState } from "./kongSpec";
+import { KongSpecActionPath, KongSpecStatePath } from "./kongSpecRef";
+export interface KongSpecValidationIssue {
+    path: KongSpecStatePath | KongSpecActionPath;
+    severity: "error" | "warning";
+    message: string;
+    fix: string;
+}
+export interface KongSpecValidators {
+    state: Array<(target: KongSpecState, path: KongSpecStatePath) => Promise<KongSpecValidationIssue[]>>;
+    action: Array<(target: KongSpecAction, path: KongSpecActionPath) => Promise<KongSpecValidationIssue[]>>;
+}
+export declare function validate(flow: KongSpecFlow, validators: KongSpecValidators): Promise<KongSpecValidationIssue[]>;

package/packages/kong-ts/src/index.d.ts

@@ -0,0 +1,37 @@
+export { compileGet, compileSet } from "./lib/accessor";
+export { generateBusinessKey } from "./lib/businessKey";
+export type { BusinessKey } from "./lib/businessKey";
+export { CloudEvent } from "./lib/cloudEvent";
+export { textToColor } from "./lib/color";
+export { deepEquals, prepareTextForComparison, sameText, shadowEquals } from "./lib/compare";
+export { isDuration } from "./lib/duration";
+export type { Duration8601 } from "./lib/duration";
+export type { Entity } from "./lib/entity";
+export { AppError, DataError, errorToPrettyString } from "./lib/error";
+export { ensureIsDuration, nonNegative, nonRecursiveCall, notBlank, notNull } from "./lib/guard";
+export { guid, stableUUID, uuidStableSequence, uuidc16, uuidc32 } from "./lib/id";
+export type { CompactUUID16, CompactUUID32, GUID, ShortUUID } from "./lib/id";
+export { intervalToString } from "./lib/interval";
+export { JqObjectSerializer, applyJqFilterReplacements, applyJqObjectReplacements, applyJqTextReplacements, extractJqTextContent, jqFilter, jqText, wrapWithJqTextMarkers, } from "./lib/jq";
+export type { JqArray, JqFilter, JqObject, JqSerializer, JqText, RefactorReplacement, } from "./lib/jq";
+export { generateFakeJsonObject, jsonToHumanReadable, prettyJson, safeJsonParse } from "./lib/json";
+export type { JsonArray, JsonObject, JsonSchemaUrl, JsonText } from "./lib/json";
+export { KeyGenerator } from "./lib/keyGenerator";
+export { insertItem, moveItem, unique } from "./lib/list";
+export { deepMerge, deepMergeAll } from "./lib/merge";
+export { deepDeleteKeys } from "./lib/normalize";
+export { retry } from "./lib/retry";
+export { fromRequestId, newRequestId } from "./lib/telemetry";
+export type { RequestId } from "./lib/telemetry";
+export { byteCount, camelize, escapeLikeText, escapeQuotes, escapeRegex, hashString, quote, removeOuterQuotes, replaceFirstOccurrence, splitToBlocks, trim, upperFirst, words, } from "./lib/text";
+export type { TextBlock } from "./lib/text";
+export { TextReader } from "./lib/textReader";
+export { DEFAULT_TIMEZONE } from "./lib/timezone";
+export type { Timezone } from "./lib/timezone";
+export type { Action, DeepPartial, Distinct, Loading, NonFunctionProperties, Optional, Pair, Primitive, PropertyPath, PropertyPathMap, RequiredProperties, Result, StringKeys, UnArray, ValidateKeys, } from "./lib/types";
+export { joinUrlAndPath, urlText } from "./lib/url";
+export type { UrlText } from "./lib/url";
+export type { User } from "./lib/user";
+export { dateToUtc, utcNow, utcToZonedDate, utcToZonedText } from "./lib/utc";
+export type { UtcDateTime } from "./lib/utc";
+export { assignDefined, clone, coalesce, getFirstObjectValue, isEmpty, isFunction, isNumber, isString, jitter, no, noop, reinterpret, safeCall, yes, } from "./lib/utils";

package/packages/kong-ts/src/lib/accessor.d.ts

@@ -0,0 +1,12 @@
+import { JsonObject, Optional, PropertyPath } from "./types";
+export type Getter<T, V> = (entry: T) => V;
+export type Setter<T, V> = (entry: T, value: V) => void;
+export interface Accessor<T, V> {
+    key: PropertyPath<T>;
+    getValue: Optional<Getter<T, V>>;
+    setValue: Optional<Setter<T, V>>;
+}
+export declare function compileGet<T extends JsonObject, V>(path: PropertyPath<T>): Getter<T, V>;
+export declare function compileSet<T extends JsonObject, V>(path: PropertyPath<T>): Setter<T, V>;
+export declare function getValueFactory<T extends JsonObject, V>(accessor: Accessor<T, V>): Getter<T, V>;
+export declare function setValueFactory<T extends JsonObject, V>(accessor: Accessor<T, V>): Setter<T, V>;

package/packages/kong-ts/src/lib/businessKey.d.ts

@@ -0,0 +1,3 @@
+import { Distinct } from "./types";
+export type BusinessKey = Distinct<string, "BusinessKey">;
+export declare function generateBusinessKey(...prefix: string[]): BusinessKey;