@skmtc/core 0.0.490 → 0.0.492

package/script/typescript/FunctionParameter.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionParameter = void 0;
+const helper_validator_identifier_1 = require("@babel/helper-validator-identifier");
+const lodash_es_1 = require("lodash-es");
+const ts_pattern_1 = require("ts-pattern");
+const List_js_1 = require("./List.js");
+class FunctionParameter {
+    constructor(args) {
+        Object.defineProperty(this, "properties", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (args.typeDefinition.value.type === 'object') {
+            this.properties = (0, ts_pattern_1.match)(args)
+                .with({ destructure: true, required: true }, ({ typeDefinition, required }) => ({
+                type: 'destructured',
+                typeDefinition: typeDefinition,
+                required
+            }))
+                .with({ name: ts_pattern_1.P.string }, ({ typeDefinition, name, required }) => ({
+                type: 'regular',
+                name,
+                typeDefinition: typeDefinition,
+                required: required ?? false
+            }))
+                .otherwise(() => {
+                throw new Error('Invalid FunctionParameter');
+            });
+        }
+        else {
+            this.properties = { type: 'void' };
+        }
+    }
+    hasProperty(name) {
+        return (0, ts_pattern_1.match)(this.properties)
+            .with({ type: 'void' }, () => false)
+            .with({ type: 'regular' }, ({ typeDefinition }) => {
+            const { value } = typeDefinition;
+            return Boolean(value.type === 'object' && value.objectProperties?.properties[name]);
+        })
+            .with({ type: 'destructured' }, ({ typeDefinition }) => {
+            return Boolean(typeDefinition.value.objectProperties?.properties[name]);
+        })
+            .exhaustive();
+    }
+    toPropertyList() {
+        return (0, ts_pattern_1.match)(this.properties)
+            .with({ type: 'void' }, () => List_js_1.List.toEmpty())
+            .with({ type: 'regular' }, ({ name }) => List_js_1.List.toSingle(name))
+            .with({ type: 'destructured' }, ({ typeDefinition }) => {
+            return List_js_1.List.fromKeys(typeDefinition.value.objectProperties?.properties).toObjectPlain();
+        })
+            .exhaustive();
+    }
+    toInbound() {
+        return (0, ts_pattern_1.match)(this.properties)
+            .with({ type: 'void' }, () => '')
+            .with({ type: 'regular' }, ({ name }) => `${name}`)
+            .with({ type: 'destructured' }, ({ typeDefinition }) => {
+            return toDestructured(typeDefinition).toString();
+        })
+            .exhaustive();
+    }
+    toString() {
+        return (0, ts_pattern_1.match)(this.properties)
+            .with({ type: 'void' }, () => '')
+            .with({ type: 'regular' }, ({ name, typeDefinition, required }) => {
+            return `${name}${required ? '' : '?'}: ${typeDefinition.identifier}`;
+        })
+            .with({ type: 'destructured' }, ({ typeDefinition }) => {
+            return List_js_1.List.toKeyValue(toDestructured(typeDefinition).toString(), typeDefinition.identifier).toString();
+        })
+            .exhaustive();
+    }
+}
+exports.FunctionParameter = FunctionParameter;
+const toDestructured = (typeDefinition) => {
+    return List_js_1.List.fromKeys(typeDefinition.value.objectProperties?.properties).toObject(key => {
+        return (0, helper_validator_identifier_1.isIdentifierName)(key) ? key : List_js_1.List.toKeyValue(key, (0, lodash_es_1.camelCase)(key));
+    });
+};

package/script/typescript/List.d.ts

@@ -0,0 +1,147 @@
+import type { Stringable } from '../dsl/Stringable.js';
+export type ListObject<V extends Stringable> = List<V[], ', ', '{}'>;
+export type ListLines<V extends Stringable> = List<V[], '\n', 'none'>;
+export type ListArray<V extends Stringable> = List<V[], ', ', '[]'>;
+export type ListParams<V extends Stringable> = List<V[], ', ', '()'>;
+export type ListKeyValue<Key extends Stringable, Value extends Stringable> = List<[
+    Key,
+    Value
+], ': ', 'none'>;
+type BookendsType = '[]' | '{}' | '()' | '<>' | 'none';
+type ConstructorOptions<Separator extends string = ', ', Bookends extends BookendsType = 'none'> = {
+    separator?: Separator;
+    bookends?: Bookends;
+};
+type ExtractArrayItem<ArrayOf> = ArrayOf extends Array<infer Item> ? Item : never;
+type ToFilteredKeyValueReturn<Value extends undefined | Stringable | Stringable[] | List> = Value extends undefined ? undefined : List<[string, Stringable | Stringable[] | List], ': ', 'none'>;
+type ToConditionalReturn<Value extends Stringable, Condition extends boolean> = Condition extends true ? List<[Value], ', ', 'none'> : List<never[], ', ', 'none'>;
+export declare class List<Values extends Stringable[] = Stringable[], Separator extends string = string, Bookends extends BookendsType = BookendsType> {
+    values: ExtractArrayItem<Values>[];
+    separator: Separator;
+    bookends: Bookends;
+    constructor(values: (ExtractArrayItem<Values> | undefined)[], { separator, bookends }?: ConstructorOptions<Separator, Bookends>);
+    toString(): string;
+    /**
+     * Create an empty List that will render as an empty string ''
+     * @returns List
+     */
+    static toEmpty: () => List<never, ", ", "none">;
+    /**
+     * Create a List with a single value that will render as `value`
+     * @param value
+     * @returns List
+     */
+    static toSingle: (value: Stringable) => List<[Stringable], ", ", "none">;
+    /**
+     * If condition is true, return a List with a single value that will render as `value`.
+     * Otherwise, return an empty List that will render as an empty string ''.
+     *
+     * Useful for conditional rendering. For example, rendering a function arg object when
+     * it has at least one property.
+     * @param value
+     * @param condition
+     * @returns List
+     */
+    static toConditional: <Value extends Stringable, Condition extends boolean>(value: Value, condition: Condition) => ToConditionalReturn<List<[Value], ", ", "none">, Condition>;
+    /**
+     * Create a record with Stringable values. KeyValue pairs will be joined with `: ` as separator
+     * and the resulting List will be wrapped with `{}`
+     * @param record
+     * @returns `record` with `Stringable` values
+     */
+    static toRecord: (record: Record<string, Stringable | Stringable[] | List>) => List<Stringable[], ", ", "{}">;
+    /**
+     * Create a record with `undefined` or empty array or List values filtered out.
+     * @param record
+     * @returns `record` with `undefined` values filtered out
+     */
+    static toFilteredRecord: (record: Record<string, undefined | Stringable | Stringable[] | List>) => ListObject<List<[string, Stringable | List<Stringable[], string, BookendsType> | Stringable[]], ": ", "none">>;
+    /**
+     * Join `key` and `value` using `: ` as separator
+     * @param key
+     * @param value
+     * @returns `key` and `value` joined with `: ` as separator
+     */
+    static toKeyValue: <Value extends Stringable | Stringable[] | List>(key: string, value: Value) => List<[string, Value], ": ", "none">;
+    /**
+     * Join `key` and `value` using `.` as separator
+     * @param key
+     * @param value
+     * @returns `key` and `value` joined with `.` as separator
+     */
+    static toObjectKey: <Value extends Stringable>(key: string, value: Value) => List<[string, Value], ".", "none">;
+    /**
+     * Join `values` using `, ` as separator and wrap in `{` and `}`
+     * @param values
+     * @returns `values` joined with `, ` as separator and wrapped in `{` and `}`
+     */
+    static toObject: <V extends Stringable>(values: (V | undefined)[]) => ListObject<V>;
+    /**
+     * Join `values` using `, ` as separator and wrap in `[` and `]`
+     * @param values
+     * @returns `values` joined with `, ` as separator and wrapped in `{` and `}`
+     */
+    static toArray: <V extends Stringable>(values: (V | undefined)[]) => ListArray<V>;
+    /**
+     * Join `values` using `, ` as separator and wrap in `(` and `)`
+     * @param values
+     * @returns `values` joined with `, ` as separator and wrapped in `(` and `)`
+     */
+    static toParams: <V extends Stringable>(values: (V | undefined)[]) => ListParams<V>;
+    /**
+     * Join `values` using `\n` as separator without a wrapper
+     * @param values
+     * @returns `values` joined with `\n` as separator without a wrapper
+     */
+    static toLines: <V extends Stringable>(values: (V | undefined)[]) => ListLines<V>;
+    /**
+     * Create a KeyList using the keys of @param record
+     * @afdafg
+     * @param record
+     * @returns KeyList
+     */
+    static fromKeys: (record: Record<string, Stringable> | undefined) => KeyList;
+    /**
+     * Create a EntryList using the entries of @param record
+     * @afdafg
+     * @param record
+     * @returns EntryList
+     */
+    static fromEntries: <T extends Stringable>(record: Record<string, T> | undefined) => EntryList<T>;
+    /**
+     * Create a keyValue pair if `value` is not undefined and is not an empty array or List.
+     * Return `undefined` otherwise.
+     *
+     * Useful for filtering out `undefined values from a record.
+     * @param key
+     * @param value
+     * @returns `key` and `value` joined with `: ` as separator if `value` is not undefined and is not an empty array or List. `undefined` otherwise.
+     */
+    static toFilteredKeyValue: <Value extends undefined | Stringable | Stringable[] | List>(key: string, value: Value) => ToFilteredKeyValueReturn<Value>;
+    /**
+     * Check if `value` is not undefined and is not an empty array or List.
+     * @param value
+     * @returns `true` if `value` is not undefined and is not an empty array or List. `false` otherwise.
+     */
+    static hasValue: (value: undefined | Stringable | Stringable[] | List) => value is Stringable | Stringable[] | List;
+}
+type KeyMapFn<V extends Stringable> = (key: string, index: number) => V;
+export declare class KeyList {
+    keys: string[];
+    constructor(keys: string[]);
+    toObject<V extends Stringable>(mapFn: KeyMapFn<V>): ListObject<V>;
+    toObjectPlain(): ListObject<string>;
+    toLines<V extends Stringable>(mapFn: KeyMapFn<V>): ListLines<V>;
+    toLinesPlain(): ListLines<string>;
+}
+type Entry<T extends Stringable> = [key: string, value: T];
+type EntryMapFn<T extends Stringable, V extends Stringable> = (entry: Entry<T>, index: number) => V | undefined;
+export declare class EntryList<T extends Stringable> {
+    entries: Entry<T>[];
+    constructor(entries: Entry<T>[]);
+    toObject<V extends Stringable>(mapFn: EntryMapFn<T, V>): ListObject<V>;
+    toLines<V extends Stringable>(mapFn: EntryMapFn<T, V>): ListLines<V>;
+    toArray<V extends Stringable>(mapFn: EntryMapFn<T, V>): ListArray<V>;
+}
+export {};
+//# sourceMappingURL=List.d.ts.map

package/script/typescript/List.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../src/typescript/List.ts"],"names":[],"mappings":"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"}

package/script/typescript/List.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryList = exports.KeyList = exports.List = void 0;
+const ts_pattern_1 = require("ts-pattern");
+class List {
+    constructor(values, { separator, bookends } = {}) {
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "separator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bookends", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.values = values.filter(value => value !== undefined);
+        this.separator = separator ?? ', ';
+        this.bookends = bookends ?? 'none';
+    }
+    toString() {
+        const joined = this.values.join(this.separator);
+        return (0, ts_pattern_1.match)(this.bookends)
+            .with('[]', () => `[${joined}]`)
+            .with('{}', () => `{${joined}}`)
+            .with('()', () => `(${joined})`)
+            .with('<>', () => `<${joined}>`)
+            .with('none', () => joined)
+            .exhaustive();
+    }
+}
+exports.List = List;
+/**
+ * Create an empty List that will render as an empty string ''
+ * @returns List
+ */
+Object.defineProperty(List, "toEmpty", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: () => {
+        return new List([], { bookends: 'none' });
+    }
+});
+/**
+ * Create a List with a single value that will render as `value`
+ * @param value
+ * @returns List
+ */
+Object.defineProperty(List, "toSingle", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (value) => {
+        return new List([value], { bookends: 'none' });
+    }
+});
+/**
+ * If condition is true, return a List with a single value that will render as `value`.
+ * Otherwise, return an empty List that will render as an empty string ''.
+ *
+ * Useful for conditional rendering. For example, rendering a function arg object when
+ * it has at least one property.
+ * @param value
+ * @param condition
+ * @returns List
+ */
+Object.defineProperty(List, "toConditional", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (value, condition) => {
+        const out = new List([condition ? value : undefined], { bookends: 'none' });
+        return out;
+    }
+});
+/**
+ * Create a record with Stringable values. KeyValue pairs will be joined with `: ` as separator
+ * and the resulting List will be wrapped with `{}`
+ * @param record
+ * @returns `record` with `Stringable` values
+ */
+Object.defineProperty(List, "toRecord", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (record) => {
+        const entries = Object.entries(record).map(([key, value]) => {
+            return List.toKeyValue(key, value);
+        });
+        return List.toObject(entries);
+    }
+});
+/**
+ * Create a record with `undefined` or empty array or List values filtered out.
+ * @param record
+ * @returns `record` with `undefined` values filtered out
+ */
+Object.defineProperty(List, "toFilteredRecord", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (record) => {
+        const entries = Object.entries(record).map(([key, value]) => {
+            return List.toFilteredKeyValue(key, value);
+        });
+        return List.toObject(entries);
+    }
+});
+/**
+ * Join `key` and `value` using `: ` as separator
+ * @param key
+ * @param value
+ * @returns `key` and `value` joined with `: ` as separator
+ */
+Object.defineProperty(List, "toKeyValue", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (key, value) => {
+        return new List([key, value], { separator: ': ' });
+    }
+});
+/**
+ * Join `key` and `value` using `.` as separator
+ * @param key
+ * @param value
+ * @returns `key` and `value` joined with `.` as separator
+ */
+Object.defineProperty(List, "toObjectKey", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (key, value) => {
+        return new List([key, value], {
+            separator: '.'
+        });
+    }
+});
+/**
+ * Join `values` using `, ` as separator and wrap in `{` and `}`
+ * @param values
+ * @returns `values` joined with `, ` as separator and wrapped in `{` and `}`
+ */
+Object.defineProperty(List, "toObject", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (values) => {
+        return new List(values, { bookends: '{}' });
+    }
+});
+/**
+ * Join `values` using `, ` as separator and wrap in `[` and `]`
+ * @param values
+ * @returns `values` joined with `, ` as separator and wrapped in `{` and `}`
+ */
+Object.defineProperty(List, "toArray", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (values) => {
+        return new List(values, { bookends: '[]' });
+    }
+});
+/**
+ * Join `values` using `, ` as separator and wrap in `(` and `)`
+ * @param values
+ * @returns `values` joined with `, ` as separator and wrapped in `(` and `)`
+ */
+Object.defineProperty(List, "toParams", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (values) => {
+        return new List(values, { bookends: '()' });
+    }
+});
+/**
+ * Join `values` using `\n` as separator without a wrapper
+ * @param values
+ * @returns `values` joined with `\n` as separator without a wrapper
+ */
+Object.defineProperty(List, "toLines", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (values) => {
+        return new List(values, { separator: '\n' });
+    }
+});
+/**
+ * Create a KeyList using the keys of @param record
+ * @afdafg
+ * @param record
+ * @returns KeyList
+ */
+Object.defineProperty(List, "fromKeys", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (record) => {
+        return new KeyList(Object.keys(record ?? {}));
+    }
+});
+/**
+ * Create a EntryList using the entries of @param record
+ * @afdafg
+ * @param record
+ * @returns EntryList
+ */
+Object.defineProperty(List, "fromEntries", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (record) => {
+        return new EntryList(Object.entries(record ?? {}));
+    }
+});
+/**
+ * Create a keyValue pair if `value` is not undefined and is not an empty array or List.
+ * Return `undefined` otherwise.
+ *
+ * Useful for filtering out `undefined values from a record.
+ * @param key
+ * @param value
+ * @returns `key` and `value` joined with `: ` as separator if `value` is not undefined and is not an empty array or List. `undefined` otherwise.
+ */
+Object.defineProperty(List, "toFilteredKeyValue", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (key, value) => {
+        const out = List.hasValue(value) ? List.toKeyValue(key, value) : undefined;
+        return out;
+    }
+});
+/**
+ * Check if `value` is not undefined and is not an empty array or List.
+ * @param value
+ * @returns `true` if `value` is not undefined and is not an empty array or List. `false` otherwise.
+ */
+Object.defineProperty(List, "hasValue", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (value) => {
+        if (value === undefined) {
+            return false;
+        }
+        if (Array.isArray(value)) {
+            return value.length > 0;
+        }
+        if (value instanceof List) {
+            return List.hasValue(value.values);
+        }
+        return true;
+    }
+});
+class KeyList {
+    constructor(keys) {
+        Object.defineProperty(this, "keys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keys = keys;
+    }
+    toObject(mapFn) {
+        return List.toObject(this.keys.map((key, index) => mapFn(key, index)));
+    }
+    toObjectPlain() {
+        return List.toObject(this.keys);
+    }
+    toLines(mapFn) {
+        return List.toLines(this.keys.map((key, index) => mapFn(key, index)));
+    }
+    toLinesPlain() {
+        return List.toLines(this.keys);
+    }
+}
+exports.KeyList = KeyList;
+class EntryList {
+    constructor(entries) {
+        Object.defineProperty(this, "entries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.entries = entries;
+    }
+    toObject(mapFn) {
+        return List.toObject(this.entries.map((entry, index) => mapFn(entry, index)));
+    }
+    toLines(mapFn) {
+        return List.toLines(this.entries.map((key, index) => mapFn(key, index)));
+    }
+    toArray(mapFn) {
+        return List.toArray(this.entries.map((entry, index) => mapFn(entry, index)));
+    }
+}
+exports.EntryList = EntryList;

package/script/typescript/PathParams.d.ts

@@ -0,0 +1,20 @@
+import type { GenerateContext } from '../context/GenerateContext.js';
+import { Definition } from '../dsl/Definition.js';
+import type { TypeSystemObject } from '../types/TypeSystem.js';
+import { FunctionParameter } from './FunctionParameter.js';
+type ConstructorArgs = {
+    context: GenerateContext;
+    argName?: string;
+    typeName: string;
+    typeValue: TypeSystemObject;
+    pathTemplate: string;
+};
+export declare class PathParams {
+    context: GenerateContext;
+    typeDefinition: Definition<TypeSystemObject>;
+    parameter: FunctionParameter;
+    path: string;
+    constructor({ context, argName, typeName, typeValue, pathTemplate }: ConstructorArgs);
+}
+export {};
+//# sourceMappingURL=PathParams.d.ts.map

package/script/typescript/PathParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/PathParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAEjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAG1D,KAAK,eAAe,GAAG;IACrB,OAAO,EAAE,eAAe,CAAA;IACxB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,gBAAgB,CAAA;IAC3B,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,qBAAa,UAAU;IACrB,OAAO,EAAE,eAAe,CAAA;IACxB,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAA;IAC5C,SAAS,EAAE,iBAAiB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;gBAEA,EACV,OAAO,EACP,OAAO,EACP,QAAQ,EACR,SAAS,EACT,YAAY,EACb,EAAE,eAAe;CAwBnB"}

package/script/typescript/PathParams.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathParams = void 0;
+const Definition_js_1 = require("../dsl/Definition.js");
+const Identifier_js_1 = require("../dsl/Identifier.js");
+const FunctionParameter_js_1 = require("./FunctionParameter.js");
+const toPathTemplate_js_1 = require("./toPathTemplate.js");
+class PathParams {
+    constructor({ context, argName, typeName, typeValue, pathTemplate }) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "typeDefinition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "parameter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.typeDefinition = new Definition_js_1.Definition({
+            context,
+            identifier: Identifier_js_1.Identifier.createType(typeName),
+            value: typeValue
+        });
+        this.parameter = new FunctionParameter_js_1.FunctionParameter({
+            name: argName,
+            typeDefinition: this.typeDefinition,
+            destructure: !argName,
+            required: true
+        });
+        const queryArg = this.parameter.properties.type === 'regular'
+            ? this.parameter.properties.name
+            : undefined;
+        // @TODO Reconcile pathTemplate with params
+        this.path = (0, toPathTemplate_js_1.toPathTemplate)(pathTemplate, queryArg);
+    }
+}
+exports.PathParams = PathParams;

package/script/typescript/ReactRouterPathParams.d.ts

@@ -0,0 +1,20 @@
+import { ValueBase } from '../dsl/ValueBase.js';
+import type { GenerateContext } from '../context/GenerateContext.js';
+import type { OasOperation } from '../oas/operation/Operation.js';
+import type { GeneratorKey } from '../types/GeneratorKeys.js';
+type CreateArgs = {
+    context: GenerateContext;
+    generatorKey: GeneratorKey;
+    operation: OasOperation;
+    destinationPath: string;
+};
+export declare class ReactRouterPathParams extends ValueBase {
+    getParams: string;
+    assertParams: string;
+    passProps: string;
+    names: string[];
+    constructor({ context, operation, generatorKey, destinationPath }: CreateArgs);
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=ReactRouterPathParams.d.ts.map

package/script/typescript/ReactRouterPathParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactRouterPathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/ReactRouterPathParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,eAAe,CAAA;IACxB,YAAY,EAAE,YAAY,CAAA;IAC1B,SAAS,EAAE,YAAY,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,SAAS,EAAE,MAAM,CAAK;IAEtB,YAAY,EAAE,MAAM,CAAK;IAEzB,SAAS,EAAE,MAAM,CAAK;IAEtB,KAAK,EAAE,MAAM,EAAE,CAAA;gBAEH,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,UAAU;IAwBpE,QAAQ,IAAI,MAAM;CAG5B"}