/* Options:
Date: 2024-04-24 23:40:20
Version: 6.111
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://test.servicestack.net

//GlobalNamespace: 
//MakePropertiesOptional: True
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
//IncludeTypes: 
//ExcludeTypes: 
//DefaultImports: 
*/


interface IReturn<T>
{
}

interface IReturnVoid
{
}

interface IPost
{
}

interface IGet
{
}

interface ICreateDb<Table>
{
}

interface IUpdateDb<Table>
{
}

interface IPatchDb<Table>
{
}

interface ISaveDb<Table>
{
}

interface IHasSessionId
{
    sessionId?: string;
}

interface IHasBearerToken
{
    bearerToken?: string;
}

interface IPut
{
}

interface IDelete
{
}

interface IPatch
{
}

interface IDeleteDb<Table>
{
}

// @DataContract
interface QueryBase
{
    // @DataMember(Order=1)
    skip?: number;

    // @DataMember(Order=2)
    take?: number;

    // @DataMember(Order=3)
    orderBy?: string;

    // @DataMember(Order=4)
    orderByDesc?: string;

    // @DataMember(Order=5)
    include?: string;

    // @DataMember(Order=6)
    fields?: string;

    // @DataMember(Order=7)
    meta?: { [index: string]: string; };
}

interface QueryDb_2<From, Into> extends QueryBase
{
}

interface Item
{
    name?: string;
    description?: string;
}

interface Poco
{
    name?: string;
}

interface CustomType
{
    id?: number;
    name?: string;
}

interface SetterType
{
    id?: number;
    name?: string;
}

interface DeclarativeChildValidation
{
    name?: string;
    // @Validate(Validator="MaximumLength(20)")
    value?: string;
}

interface FluentChildValidation
{
    name?: string;
    value?: string;
}

interface DeclarativeSingleValidation
{
    name?: string;
    // @Validate(Validator="MaximumLength(20)")
    value?: string;
}

interface FluentSingleValidation
{
    name?: string;
    value?: string;
}

// @DataContract
interface CancelRequest extends IPost
{
    // @DataMember(Order=1)
    tag?: string;

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };
}

// @DataContract
interface ResponseError
{
    // @DataMember(Order=1)
    errorCode?: string;

    // @DataMember(Order=2)
    fieldName?: string;

    // @DataMember(Order=3)
    message?: string;

    // @DataMember(Order=4)
    meta?: { [index: string]: string; };
}

// @DataContract
interface ResponseStatus
{
    // @DataMember(Order=1)
    errorCode?: string;

    // @DataMember(Order=2)
    message?: string;

    // @DataMember(Order=3)
    stackTrace?: string;

    // @DataMember(Order=4)
    errors?: ResponseError[];

    // @DataMember(Order=5)
    meta?: { [index: string]: string; };
}

// @DataContract
interface CancelRequestResponse
{
    // @DataMember(Order=1)
    tag?: string;

    // @DataMember(Order=2)
    elapsed?: string;

    // @DataMember(Order=3)
    meta?: { [index: string]: string; };

    // @DataMember(Order=4)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface UpdateEventSubscriber extends IPost
{
    // @DataMember(Order=1)
    id?: string;

    // @DataMember(Order=2)
    subscribeChannels?: string[];

    // @DataMember(Order=3)
    unsubscribeChannels?: string[];
}

// @DataContract
interface UpdateEventSubscriberResponse
{
    // @DataMember(Order=1)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface GetApiKeys extends IGet
{
    // @DataMember(Order=1)
    environment?: string;

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };
}

// @DataContract
interface UserApiKey
{
    // @DataMember(Order=1)
    key?: string;

    // @DataMember(Order=2)
    keyType?: string;

    // @DataMember(Order=3)
    expiryDate?: string;

    // @DataMember(Order=4)
    meta?: { [index: string]: string; };
}

// @DataContract
interface GetApiKeysResponse
{
    // @DataMember(Order=1)
    results?: UserApiKey[];

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };

    // @DataMember(Order=3)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface RegenerateApiKeys extends IPost
{
    // @DataMember(Order=1)
    environment?: string;

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };
}

// @DataContract
interface RegenerateApiKeysResponse
{
    // @DataMember(Order=1)
    results?: UserApiKey[];

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };

    // @DataMember(Order=3)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface ConvertSessionToToken extends IPost
{
    // @DataMember(Order=1)
    preserveSession?: boolean;

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };
}

// @DataContract
interface ConvertSessionToTokenResponse
{
    // @DataMember(Order=1)
    meta?: { [index: string]: string; };

    // @DataMember(Order=2)
    accessToken?: string;

    // @DataMember(Order=3)
    refreshToken?: string;

    // @DataMember(Order=4)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface GetAccessToken extends IPost
{
    // @DataMember(Order=1)
    refreshToken?: string;

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };
}

// @DataContract
interface GetAccessTokenResponse
{
    // @DataMember(Order=1)
    accessToken?: string;

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };

    // @DataMember(Order=3)
    responseStatus?: ResponseStatus;
}

interface NavItem
{
    label?: string;
    href?: string;
    exact?: boolean;
    id?: string;
    className?: string;
    iconClass?: string;
    iconSrc?: string;
    show?: string;
    hide?: string;
    children?: NavItem[];
    meta?: { [index: string]: string; };
}

// @DataContract
interface GetNavItems
{
    // @DataMember(Order=1)
    name?: string;
}

// @DataContract
interface GetNavItemsResponse
{
    // @DataMember(Order=1)
    baseUrl?: string;

    // @DataMember(Order=2)
    results?: NavItem[];

    // @DataMember(Order=3)
    navItemsMap?: { [index: string]: NavItem[]; };

    // @DataMember(Order=4)
    meta?: { [index: string]: string; };

    // @DataMember(Order=5)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface IdResponse
{
    // @DataMember(Order=1)
    id?: string;

    // @DataMember(Order=2)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface StringResponse
{
    // @DataMember(Order=1)
    result?: string;

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };

    // @DataMember(Order=3)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface StringsResponse
{
    // @DataMember(Order=1)
    results?: string[];

    // @DataMember(Order=2)
    meta?: { [index: string]: string; };

    // @DataMember(Order=3)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface AuditBase
{
    // @DataMember(Order=1)
    createdDate?: string;

    // @DataMember(Order=2)
    // @Required()
    createdBy?: string;

    // @DataMember(Order=3)
    modifiedDate?: string;

    // @DataMember(Order=4)
    // @Required()
    modifiedBy?: string;

    // @DataMember(Order=5)
    deletedDate?: string;

    // @DataMember(Order=6)
    deletedBy?: string;
}

interface IAuthTokens
{
    provider?: string;
    userId?: string;
    accessToken?: string;
    accessTokenSecret?: string;
    refreshToken?: string;
    refreshTokenExpiry?: string;
    requestToken?: string;
    requestTokenSecret?: string;
    items?: { [index: string]: string; };
}

// @DataContract
interface AuthUserSession
{
    // @DataMember(Order=1)
    referrerUrl?: string;

    // @DataMember(Order=2)
    id?: string;

    // @DataMember(Order=3)
    userAuthId?: string;

    // @DataMember(Order=4)
    userAuthName?: string;

    // @DataMember(Order=5)
    userName?: string;

    // @DataMember(Order=6)
    twitterUserId?: string;

    // @DataMember(Order=7)
    twitterScreenName?: string;

    // @DataMember(Order=8)
    facebookUserId?: string;

    // @DataMember(Order=9)
    facebookUserName?: string;

    // @DataMember(Order=10)
    firstName?: string;

    // @DataMember(Order=11)
    lastName?: string;

    // @DataMember(Order=12)
    displayName?: string;

    // @DataMember(Order=13)
    company?: string;

    // @DataMember(Order=14)
    email?: string;

    // @DataMember(Order=15)
    primaryEmail?: string;

    // @DataMember(Order=16)
    phoneNumber?: string;

    // @DataMember(Order=17)
    birthDate?: string;

    // @DataMember(Order=18)
    birthDateRaw?: string;

    // @DataMember(Order=19)
    address?: string;

    // @DataMember(Order=20)
    address2?: string;

    // @DataMember(Order=21)
    city?: string;

    // @DataMember(Order=22)
    state?: string;

    // @DataMember(Order=23)
    country?: string;

    // @DataMember(Order=24)
    culture?: string;

    // @DataMember(Order=25)
    fullName?: string;

    // @DataMember(Order=26)
    gender?: string;

    // @DataMember(Order=27)
    language?: string;

    // @DataMember(Order=28)
    mailAddress?: string;

    // @DataMember(Order=29)
    nickname?: string;

    // @DataMember(Order=30)
    postalCode?: string;

    // @DataMember(Order=31)
    timeZone?: string;

    // @DataMember(Order=32)
    requestTokenSecret?: string;

    // @DataMember(Order=33)
    createdAt?: string;

    // @DataMember(Order=34)
    lastModified?: string;

    // @DataMember(Order=35)
    roles?: string[];

    // @DataMember(Order=36)
    permissions?: string[];

    // @DataMember(Order=37)
    isAuthenticated?: boolean;

    // @DataMember(Order=38)
    fromToken?: boolean;

    // @DataMember(Order=39)
    profileUrl?: string;

    // @DataMember(Order=40)
    sequence?: string;

    // @DataMember(Order=41)
    tag?: number;

    // @DataMember(Order=42)
    authProvider?: string;

    // @DataMember(Order=43)
    providerOAuthAccess?: IAuthTokens[];

    // @DataMember(Order=44)
    meta?: { [index: string]: string; };

    // @DataMember(Order=45)
    audiences?: string[];

    // @DataMember(Order=46)
    scopes?: string[];

    // @DataMember(Order=47)
    dns?: string;

    // @DataMember(Order=48)
    rsa?: string;

    // @DataMember(Order=49)
    sid?: string;

    // @DataMember(Order=50)
    hash?: string;

    // @DataMember(Order=51)
    homePhone?: string;

    // @DataMember(Order=52)
    mobilePhone?: string;

    // @DataMember(Order=53)
    webpage?: string;

    // @DataMember(Order=54)
    emailConfirmed?: boolean;

    // @DataMember(Order=55)
    phoneNumberConfirmed?: boolean;

    // @DataMember(Order=56)
    twoFactorEnabled?: boolean;

    // @DataMember(Order=57)
    securityStamp?: string;

    // @DataMember(Order=58)
    type?: string;

    // @DataMember(Order=59)
    recoveryToken?: string;

    // @DataMember(Order=60)
    refId?: number;

    // @DataMember(Order=61)
    refIdStr?: string;
}

interface NestedClass
{
    value?: string;
}

type EnumType = "Value1" | "Value2" | "Value3";

// @Flags()
type EnumTypeFlags = "Value1" | "Value2" | "Value3";

type EnumWithValues = "None" | "Value1" | "Value2";

// @Flags()
type EnumFlags = "Value0" | "Value1" | "Value2" | "Value3" | "Value123";

type EnumAsInt = "Value1" | "Value2" | "Value3";

type EnumStyle = "lower" | "UPPER" | "PascalCase" | "camelCase" | "camelUPPER" | "PascalUPPER";

type EnumStyleMembers = "Lower" | "Upper" | "PascalCase" | "CamelCase" | "CamelUpper" | "PascalUpper";

interface KeyValuePair<TKey, TValue>
{
    key?: TKey;
    value?: TValue;
}

interface SubType
{
    id?: number;
    name?: string;
}

interface AllTypesBase
{
    id?: number;
    nullableId?: number;
    byte?: number;
    short?: number;
    int?: number;
    long?: number;
    uShort?: number;
    uInt?: number;
    uLong?: number;
    float?: number;
    double?: number;
    decimal?: number;
    string?: string;
    dateTime?: string;
    timeSpan?: string;
    dateTimeOffset?: string;
    guid?: string;
    char?: string;
    keyValuePair?: KeyValuePair<string, string>;
    nullableDateTime?: string;
    nullableTimeSpan?: string;
    stringList?: string[];
    stringArray?: string[];
    stringMap?: { [index: string]: string; };
    intStringMap?: { [index: number]: string; };
    subType?: SubType;
}

interface HelloBase
{
    id?: number;
}

interface HelloBase_1<T>
{
    items?: T[];
    counts?: number[];
}

interface IPoco
{
    name?: string;
}

interface IEmptyInterface
{
}

interface EmptyClass
{
}

type DayOfWeek = "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday";

// @DataContract
type ScopeType = "Global" | "Sale";

interface PingService
{
}

interface Channel
{
    name?: string;
    value?: string;
}

interface Device
{
    id?: number;
    type?: string;
    timeStamp?: number;
    channels?: Channel[];
}

interface Logger
{
    id?: number;
    devices?: Device[];
}

interface Rockstar
{
    id?: number;
    firstName?: string;
    lastName?: string;
    age?: number;
}

interface QueryDbTenant_2<From, Into> extends QueryDb_2<From, Into>
{
}

type LivingStatus = "Alive" | "Dead";

interface RockstarAuditTenant extends AuditBase
{
    tenantId?: number;
    id?: number;
    firstName?: string;
    lastName?: string;
    age?: number;
    dateOfBirth?: string;
    dateDied?: string;
    livingStatus?: LivingStatus;
}

interface RockstarBase
{
    firstName?: string;
    lastName?: string;
    age?: number;
    dateOfBirth?: string;
    dateDied?: string;
    livingStatus?: LivingStatus;
}

interface RockstarAuto extends RockstarBase
{
    id?: number;
}

interface QueryDb_1<T> extends QueryBase
{
}

interface OnlyDefinedInGenericType
{
    id?: number;
    name?: string;
}

interface OnlyDefinedInGenericTypeFrom
{
    id?: number;
    name?: string;
}

interface OnlyDefinedInGenericTypeInto
{
    id?: number;
    name?: string;
}

interface RockstarAudit extends RockstarBase
{
    id?: number;
    createdDate?: string;
    createdBy?: string;
    createdInfo?: string;
    modifiedDate?: string;
    modifiedBy?: string;
    modifiedInfo?: string;
}

interface CreateAuditBase<Table, TResponse> extends ICreateDb<Table>
{
}

interface CreateAuditTenantBase<Table, TResponse> extends CreateAuditBase<Table, TResponse>
{
}

interface UpdateAuditBase<Table, TResponse> extends IUpdateDb<Table>
{
}

interface UpdateAuditTenantBase<Table, TResponse> extends UpdateAuditBase<Table, TResponse>
{
}

interface PatchAuditBase<Table, TResponse> extends IPatchDb<Table>
{
}

interface PatchAuditTenantBase<Table, TResponse> extends PatchAuditBase<Table, TResponse>
{
}

interface SoftDeleteAuditBase<Table, TResponse> extends IUpdateDb<Table>
{
}

interface SoftDeleteAuditTenantBase<Table, TResponse> extends SoftDeleteAuditBase<Table, TResponse>
{
}

interface RockstarVersion extends RockstarBase
{
    id?: number;
    rowVersion?: number;
}

// @Route("/messages/crud/{Id}", "PUT")
interface MessageCrud extends IReturnVoid, ISaveDb<MessageCrud>
{
    id?: number;
    name?: string;
}

interface MetadataTestNestedChild
{
    name?: string;
}

interface MetadataTestChild
{
    name?: string;
    results?: MetadataTestNestedChild[];
}

interface MenuItemExampleItem
{
    // @DataMember(Order=1)
    // @ApiMember()
    name1?: string;
}

interface MenuItemExample
{
    // @DataMember(Order=1)
    // @ApiMember()
    name1?: string;

    menuItemExampleItem?: MenuItemExampleItem;
}

// @DataContract
interface MenuExample
{
    // @DataMember(Order=1)
    // @ApiMember()
    menuItemExample1?: MenuItemExample;
}

interface ListResult
{
    result?: string;
}

interface ArrayResult
{
    result?: string;
}

interface HelloResponseBase
{
    refId?: number;
}

interface HelloWithReturnResponse
{
    result?: string;
}

interface HelloType
{
    result?: string;
}

interface InnerType
{
    id?: number;
    name?: string;
}

type InnerEnum = "Foo" | "Bar" | "Baz";

interface ReturnedDto
{
    id?: number;
}

interface CustomUserSession extends AuthUserSession
{
    // @DataMember
    customName?: string;

    // @DataMember
    customInfo?: string;
}

interface UnAuthInfo
{
    customInfo?: string;
}

interface TypesGroup
{
}

// @DataContract
interface QueryResponse<Poco>
{
    // @DataMember(Order=1)
    offset?: number;

    // @DataMember(Order=2)
    total?: number;

    // @DataMember(Order=3)
    results?: Poco[];

    // @DataMember(Order=4)
    meta?: { [index: string]: string; };

    // @DataMember(Order=5)
    responseStatus?: ResponseStatus;
}

interface ChatMessage
{
    id?: number;
    channel?: string;
    fromUserId?: string;
    fromName?: string;
    displayName?: string;
    message?: string;
    userAuthId?: string;
    private?: boolean;
}

interface GetChatHistoryResponse
{
    results?: ChatMessage[];
    responseStatus?: ResponseStatus;
}

interface GetUserDetailsResponse
{
    provider?: string;
    userId?: string;
    userName?: string;
    fullName?: string;
    displayName?: string;
    firstName?: string;
    lastName?: string;
    company?: string;
    email?: string;
    phoneNumber?: string;
    birthDate?: string;
    birthDateRaw?: string;
    address?: string;
    address2?: string;
    city?: string;
    state?: string;
    country?: string;
    culture?: string;
    gender?: string;
    language?: string;
    mailAddress?: string;
    nickname?: string;
    postalCode?: string;
    timeZone?: string;
}

interface CustomHttpErrorResponse
{
    custom?: string;
    responseStatus?: ResponseStatus;
}

interface QueryResponseAlt<Item>
{
    offset?: number;
    total?: number;
    results?: Item[];
    meta?: { [index: string]: string; };
    responseStatus?: ResponseStatus;
}

interface Items
{
    results?: Item[];
}

// @DataContract
interface EmptyResponse
{
    // @DataMember(Order=1)
    responseStatus?: ResponseStatus;
}

interface ReturnCustom400Response
{
    responseStatus?: ResponseStatus;
}

interface ThrowTypeResponse
{
    responseStatus?: ResponseStatus;
}

interface ThrowValidationResponse
{
    age?: number;
    required?: string;
    email?: string;
    responseStatus?: ResponseStatus;
}

interface ThrowBusinessErrorResponse
{
    responseStatus?: ResponseStatus;
}

interface Account
{
    name?: string;
}

interface Project
{
    account?: string;
    name?: string;
}

interface SecuredResponse
{
    result?: string;
    responseStatus?: ResponseStatus;
}

interface CreateJwtResponse
{
    token?: string;
    responseStatus?: ResponseStatus;
}

interface CreateRefreshJwtResponse
{
    token?: string;
    responseStatus?: ResponseStatus;
}

interface MetadataTestResponse
{
    id?: number;
    results?: MetadataTestChild[];
}

// @DataContract
interface GetExampleResponse
{
    // @DataMember(Order=1)
    responseStatus?: ResponseStatus;

    // @DataMember(Order=2)
    // @ApiMember()
    menuExample1?: MenuExample;
}

// @Route("/messages/{Id}", "PUT")
interface Message extends IReturn<Message>
{
    id?: number;
    name?: string;
}

interface GetRandomIdsResponse
{
    results?: string[];
}

interface HelloResponse
{
    result?: string;
}

interface AllTypes extends IReturn<AllTypes>
{
    id?: number;
    nullableId?: number;
    byte?: number;
    short?: number;
    int?: number;
    long?: number;
    uShort?: number;
    uInt?: number;
    uLong?: number;
    float?: number;
    double?: number;
    decimal?: number;
    string?: string;
    dateTime?: string;
    timeSpan?: string;
    dateTimeOffset?: string;
    guid?: string;
    char?: string;
    keyValuePair?: KeyValuePair<string, string>;
    nullableDateTime?: string;
    nullableTimeSpan?: string;
    stringList?: string[];
    stringArray?: string[];
    stringMap?: { [index: string]: string; };
    intStringMap?: { [index: number]: string; };
    subType?: SubType;
}

interface AllCollectionTypes extends IReturn<AllCollectionTypes>
{
    intArray?: number[];
    intList?: number[];
    stringArray?: string[];
    stringList?: string[];
    floatArray?: number[];
    doubleList?: number[];
    byteArray?: string;
    charArray?: string[];
    decimalList?: number[];
    pocoArray?: Poco[];
    pocoList?: Poco[];
    pocoLookup?: { [index: string]: Poco[]; };
    pocoLookupMap?: { [index: string]: { [index:string]: Poco; }[]; };
}

interface HelloAllTypesResponse
{
    result?: string;
    allTypes?: AllTypes;
    allCollectionTypes?: AllCollectionTypes;
}

interface SubAllTypes extends AllTypesBase
{
    hierarchy?: number;
}

interface HelloDateTime extends IReturn<HelloDateTime>
{
    dateTime?: string;
}

// @DataContract
interface HelloWithDataContractResponse
{
    // @DataMember(Name="result", Order=1, IsRequired=true, EmitDefaultValue=false)
    result?: string;
}

/** @description Description on HelloWithDescriptionResponse type */
interface HelloWithDescriptionResponse
{
    result?: string;
}

interface HelloWithInheritanceResponse extends HelloResponseBase
{
    result?: string;
}

interface HelloWithAlternateReturnResponse extends HelloWithReturnResponse
{
    altResult?: string;
}

interface HelloWithRouteResponse
{
    result?: string;
}

interface HelloWithTypeResponse
{
    result?: HelloType;
}

interface HelloInnerTypesResponse
{
    innerType?: InnerType;
    innerEnum?: InnerEnum;
}

interface HelloVerbResponse
{
    result?: string;
}

interface EnumResponse
{
    operator?: ScopeType;
}

// @Route("/hellotypes/{Name}")
interface HelloTypes extends IReturn<HelloTypes>
{
    string?: string;
    bool?: boolean;
    int?: number;
}

// @DataContract
interface HelloZipResponse
{
    // @DataMember
    result?: string;
}

interface PingResponse
{
    responses?: { [index: string]: ResponseStatus; };
    responseStatus?: ResponseStatus;
}

interface RequiresRoleResponse
{
    result?: string;
    responseStatus?: ResponseStatus;
}

interface SendVerbResponse
{
    id?: number;
    pathInfo?: string;
    requestMethod?: string;
}

interface GetSessionResponse
{
    result?: CustomUserSession;
    unAuthInfo?: UnAuthInfo;
    responseStatus?: ResponseStatus;
}

// @DataContract(Namespace="http://schemas.servicestack.net/types")
interface GetStuffResponse
{
    // @DataMember
    summaryDate?: string;

    // @DataMember
    summaryEndDate?: string;

    // @DataMember
    symbol?: string;

    // @DataMember
    email?: string;

    // @DataMember
    isEnabled?: boolean;
}

interface StoreLogsResponse
{
    existingLogs?: Logger[];
    responseStatus?: ResponseStatus;
}

interface TestAuthResponse
{
    userId?: string;
    sessionId?: string;
    userName?: string;
    displayName?: string;
    responseStatus?: ResponseStatus;
}

interface RequiresAdmin extends IReturn<RequiresAdmin>
{
    id?: number;
}

// @Route("/custom")
// @Route("/custom/{Data}")
interface CustomRoute extends IReturn<CustomRoute>
{
    data?: string;
}

// @Route("/wait/{ForMs}")
interface Wait extends IReturn<Wait>
{
    forMs?: number;
}

// @Route("/echo/types")
interface EchoTypes extends IReturn<EchoTypes>
{
    byte?: number;
    short?: number;
    int?: number;
    long?: number;
    uShort?: number;
    uInt?: number;
    uLong?: number;
    float?: number;
    double?: number;
    decimal?: number;
    string?: string;
    dateTime?: string;
    timeSpan?: string;
    dateTimeOffset?: string;
    guid?: string;
    char?: string;
}

// @Route("/echo/collections")
interface EchoCollections extends IReturn<EchoCollections>
{
    stringList?: string[];
    stringArray?: string[];
    stringMap?: { [index: string]: string; };
    intStringMap?: { [index: number]: string; };
}

// @Route("/echo/complex")
interface EchoComplexTypes extends IReturn<EchoComplexTypes>
{
    subType?: SubType;
    subTypes?: SubType[];
    subTypeMap?: { [index: string]: SubType; };
    stringMap?: { [index: string]: string; };
    intStringMap?: { [index: number]: string; };
}

// @Route("/rockstars", "POST")
interface StoreRockstars extends Array<Rockstar>, IReturn<StoreRockstars>
{
}

// @DataContract
interface AuthenticateResponse extends IHasSessionId, IHasBearerToken
{
    // @DataMember(Order=1)
    userId?: string;

    // @DataMember(Order=2)
    sessionId?: string;

    // @DataMember(Order=3)
    userName?: string;

    // @DataMember(Order=4)
    displayName?: string;

    // @DataMember(Order=5)
    referrerUrl?: string;

    // @DataMember(Order=6)
    bearerToken?: string;

    // @DataMember(Order=7)
    refreshToken?: string;

    // @DataMember(Order=8)
    profileUrl?: string;

    // @DataMember(Order=9)
    roles?: string[];

    // @DataMember(Order=10)
    permissions?: string[];

    // @DataMember(Order=11)
    responseStatus?: ResponseStatus;

    // @DataMember(Order=12)
    meta?: { [index: string]: string; };
}

// @DataContract
interface AssignRolesResponse
{
    // @DataMember(Order=1)
    allRoles?: string[];

    // @DataMember(Order=2)
    allPermissions?: string[];

    // @DataMember(Order=3)
    meta?: { [index: string]: string; };

    // @DataMember(Order=4)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface UnAssignRolesResponse
{
    // @DataMember(Order=1)
    allRoles?: string[];

    // @DataMember(Order=2)
    allPermissions?: string[];

    // @DataMember(Order=3)
    meta?: { [index: string]: string; };

    // @DataMember(Order=4)
    responseStatus?: ResponseStatus;
}

// @DataContract
interface RegisterResponse extends IHasSessionId, IHasBearerToken
{
    // @DataMember(Order=1)
    userId?: string;

    // @DataMember(Order=2)
    sessionId?: string;

    // @DataMember(Order=3)
    userName?: string;

    // @DataMember(Order=4)
    referrerUrl?: string;

    // @DataMember(Order=5)
    bearerToken?: string;

    // @DataMember(Order=6)
    refreshToken?: string;

    // @DataMember(Order=7)
    roles?: string[];

    // @DataMember(Order=8)
    permissions?: string[];

    // @DataMember(Order=9)
    responseStatus?: ResponseStatus;

    // @DataMember(Order=10)
    meta?: { [index: string]: string; };
}

interface RockstarWithIdResponse
{
    id?: number;
    responseStatus?: ResponseStatus;
}

interface RockstarWithIdAndResultResponse
{
    id?: number;
    result?: RockstarAuto;
    responseStatus?: ResponseStatus;
}

interface RockstarWithIdAndCountResponse
{
    id?: number;
    count?: number;
    responseStatus?: ResponseStatus;
}

interface RockstarWithIdAndRowVersionResponse
{
    id?: number;
    rowVersion?: number;
    responseStatus?: ResponseStatus;
}

interface QueryItems extends QueryDb_2<Item, Poco>, IReturn<QueryResponse<Poco>>
{
}

// @Route("/channels/{Channel}/raw")
interface PostRawToChannel extends IReturnVoid
{
    from?: string;
    toUserId?: string;
    channel?: string;
    message?: string;
    selector?: string;
}

// @Route("/channels/{Channel}/chat")
interface PostChatToChannel extends IReturn<ChatMessage>
{
    from?: string;
    toUserId?: string;
    channel?: string;
    message?: string;
    selector?: string;
}

// @Route("/chathistory")
interface GetChatHistory extends IReturn<GetChatHistoryResponse>
{
    channels?: string[];
    afterId?: number;
    take?: number;
}

// @Route("/reset")
interface ClearChatHistory extends IReturnVoid
{
}

// @Route("/reset-serverevents")
interface ResetServerEvents extends IReturnVoid
{
}

// @Route("/channels/{Channel}/object")
interface PostObjectToChannel extends IReturnVoid
{
    toUserId?: string;
    channel?: string;
    selector?: string;
    customType?: CustomType;
    setterType?: SetterType;
}

// @Route("/account")
interface GetUserDetails extends IReturn<GetUserDetailsResponse>
{
}

interface CustomHttpError extends IReturn<CustomHttpErrorResponse>
{
    statusCode?: number;
    statusDescription?: string;
}

interface AltQueryItems extends IReturn<QueryResponseAlt<Item>>
{
    name?: string;
}

interface GetItems extends IReturn<Items>
{
}

interface GetNakedItems extends IReturn<Item[]>
{
}

// @ValidateRequest(Validator="IsAuthenticated")
interface DeclarativeValidationAuth
{
    name?: string;
}

interface DeclarativeCollectiveValidationTest extends IReturn<EmptyResponse>
{
    // @Validate(Validator="NotEmpty")
    // @Validate(Validator="MaximumLength(20)")
    site?: string;

    declarativeValidations?: DeclarativeChildValidation[];
    fluentValidations?: FluentChildValidation[];
}

interface DeclarativeSingleValidationTest extends IReturn<EmptyResponse>
{
    // @Validate(Validator="NotEmpty")
    // @Validate(Validator="MaximumLength(20)")
    site?: string;

    declarativeSingleValidation?: DeclarativeSingleValidation;
    fluentSingleValidation?: FluentSingleValidation;
}

interface DummyTypes
{
    helloResponses?: HelloResponse[];
    listResult?: ListResult[];
    arrayResult?: ArrayResult[];
    cancelRequest?: CancelRequest;
    cancelRequestResponse?: CancelRequestResponse;
    updateEventSubscriber?: UpdateEventSubscriber;
    updateEventSubscriberResponse?: UpdateEventSubscriberResponse;
    getApiKeys?: GetApiKeys;
    getApiKeysResponse?: GetApiKeysResponse;
    regenerateApiKeys?: RegenerateApiKeys;
    regenerateApiKeysResponse?: RegenerateApiKeysResponse;
    userApiKey?: UserApiKey;
    convertSessionToToken?: ConvertSessionToToken;
    convertSessionToTokenResponse?: ConvertSessionToTokenResponse;
    getAccessToken?: GetAccessToken;
    getAccessTokenResponse?: GetAccessTokenResponse;
    navItem?: NavItem;
    getNavItems?: GetNavItems;
    getNavItemsResponse?: GetNavItemsResponse;
    emptyResponse?: EmptyResponse;
    idResponse?: IdResponse;
    stringResponse?: StringResponse;
    stringsResponse?: StringsResponse;
    auditBase?: AuditBase;
}

// @Route("/throwhttperror/{Status}")
interface ThrowHttpError
{
    status?: number;
    message?: string;
}

// @Route("/throw404")
// @Route("/throw404/{Message}")
interface Throw404
{
    message?: string;
}

// @Route("/throwcustom400")
// @Route("/throwcustom400/{Message}")
interface ThrowCustom400
{
    message?: string;
}

// @Route("/returncustom400")
// @Route("/returncustom400/{Message}")
interface ReturnCustom400 extends IReturn<ReturnCustom400Response>
{
    message?: string;
}

// @Route("/throw/{Type}")
interface ThrowType extends IReturn<ThrowTypeResponse>
{
    type?: string;
    message?: string;
}

// @Route("/throwvalidation")
interface ThrowValidation extends IReturn<ThrowValidationResponse>
{
    age?: number;
    required?: string;
    email?: string;
}

// @Route("/throwbusinesserror")
interface ThrowBusinessError extends IReturn<ThrowBusinessErrorResponse>
{
}

interface RootPathRoutes
{
    path?: string;
}

interface GetAccount extends IReturn<Account>
{
    account?: string;
}

interface GetProject extends IReturn<Project>
{
    account?: string;
    project?: string;
}

// @Route("/image-stream")
interface ImageAsStream extends IReturn<Blob>
{
    format?: string;
}

// @Route("/image-bytes")
interface ImageAsBytes extends IReturn<Uint8Array>
{
    format?: string;
}

// @Route("/image-custom")
interface ImageAsCustomResult extends IReturn<Uint8Array>
{
    format?: string;
}

// @Route("/image-response")
interface ImageWriteToResponse extends IReturn<Uint8Array>
{
    format?: string;
}

// @Route("/image-file")
interface ImageAsFile extends IReturn<Uint8Array>
{
    format?: string;
}

// @Route("/image-redirect")
interface ImageAsRedirect
{
    format?: string;
}

// @Route("/hello-image/{Name}")
interface HelloImage extends IReturn<Uint8Array>
{
    name?: string;
    format?: string;
    width?: number;
    height?: number;
    fontSize?: number;
    fontFamily?: string;
    foreground?: string;
    background?: string;
}

// @Route("/secured")
// @ValidateRequest(Validator="IsAuthenticated")
interface Secured extends IReturn<SecuredResponse>
{
    name?: string;
}

// @Route("/jwt")
interface CreateJwt extends AuthUserSession, IReturn<CreateJwtResponse>
{
    jwtExpiry?: string;
}

// @Route("/jwt-refresh")
interface CreateRefreshJwt extends IReturn<CreateRefreshJwtResponse>
{
    userAuthId?: string;
    jwtExpiry?: string;
}

// @Route("/jwt-invalidate")
interface InvalidateLastAccessToken extends IReturn<EmptyResponse>
{
}

// @Route("/logs")
interface ViewLogs extends IReturn<string>
{
    clear?: boolean;
}

// @Route("/metadatatest")
interface MetadataTest extends IReturn<MetadataTestResponse>
{
    id?: number;
}

// @Route("/metadatatest-array")
interface MetadataTestArray extends IReturn<MetadataTestChild[]>
{
    id?: number;
}

// @Route("/example", "GET")
// @DataContract
interface GetExample extends IReturn<GetExampleResponse>
{
}

// @Route("/messages/{Id}", "GET")
interface RequestMessage extends IReturn<Message>
{
    id?: number;
}

// @Route("/randomids")
interface GetRandomIds extends IReturn<GetRandomIdsResponse>
{
    take?: number;
}

// @Route("/textfile-test")
interface TextFileTest
{
    asAttachment?: boolean;
}

// @Route("/return/text")
interface ReturnText
{
    text?: string;
}

// @Route("/return/html")
interface ReturnHtml
{
    text?: string;
}

// @Route("/hello")
// @Route("/hello/{Name}")
interface Hello extends IReturn<HelloResponse>
{
    // @Required()
    name?: string;

    title?: string;
}

// @Route("/hello-secure/{Name}")
// @ValidateRequest(Validator="IsAuthenticated")
interface HelloSecure extends IReturn<HelloResponse>
{
    name?: string;
}

interface HelloWithNestedClass extends IReturn<HelloResponse>
{
    name?: string;
    nestedClassProp?: NestedClass;
}

interface HelloList extends IReturn<ListResult[]>
{
    names?: string[];
}

interface HelloArray extends IReturn<ArrayResult[]>
{
    names?: string[];
}

interface HelloMap extends IReturn<{ [index: string]: ArrayResult; }>
{
    names?: string[];
}

interface HelloQueryResponse extends IReturn<QueryResponse<string>>
{
    names?: string[];
}

interface HelloWithEnum
{
    enumProp?: EnumType;
    enumTypeFlags?: EnumTypeFlags;
    enumWithValues?: EnumWithValues;
    nullableEnumProp?: EnumType;
    enumFlags?: EnumFlags;
    enumAsInt?: EnumAsInt;
    enumStyle?: EnumStyle;
    enumStyleMembers?: EnumStyleMembers;
}

interface HelloWithEnumList
{
    enumProp?: EnumType[];
    enumWithValues?: EnumWithValues[];
    nullableEnumProp?: EnumType[];
    enumFlags?: EnumFlags[];
    enumStyle?: EnumStyle[];
}

interface HelloWithEnumMap
{
    enumProp?: { [index: string]: EnumType; };
    enumWithValues?: { [index: string]: EnumWithValues; };
    nullableEnumProp?: { [index: string]: EnumType; };
    enumFlags?: { [index: string]: EnumFlags; };
    enumStyle?: { [index: string]: EnumStyle; };
}

interface HelloExternal
{
    name?: string;
}

/** @description AllowedAttributes Description */
// @Route("/allowed-attributes", "GET")
// @Api(Description="AllowedAttributes Description")
// @ApiResponse(Description="Your request was not understood", StatusCode=400)
// @DataContract
interface AllowedAttributes
{
    /** @description Range Description */
    // @DataMember(Name="Aliased")
    // @ApiMember(DataType="double", Description="Range Description", IsRequired=true, ParameterType="path")
    Aliased?: number;
}

// @Route("/all-types")
interface HelloAllTypes extends IReturn<HelloAllTypesResponse>
{
    name?: string;
    allTypes?: AllTypes;
    allCollectionTypes?: AllCollectionTypes;
}

interface HelloSubAllTypes extends AllTypesBase, IReturn<SubAllTypes>
{
    hierarchy?: number;
}

interface HelloString extends IReturn<string>
{
    name?: string;
}

interface HelloVoid
{
    name?: string;
}

// @DataContract
interface HelloWithDataContract extends IReturn<HelloWithDataContractResponse>
{
    // @DataMember(Name="name", Order=1, IsRequired=true, EmitDefaultValue=false)
    name?: string;

    // @DataMember(Name="id", Order=2, EmitDefaultValue=false)
    id?: number;
}

/** @description Description on HelloWithDescription type */
interface HelloWithDescription extends IReturn<HelloWithDescriptionResponse>
{
    name?: string;
}

interface HelloWithInheritance extends HelloBase, IReturn<HelloWithInheritanceResponse>
{
    name?: string;
}

interface HelloWithGenericInheritance extends HelloBase_1<Poco>
{
    result?: string;
}

interface HelloWithGenericInheritance2 extends HelloBase_1<Hello>
{
    result?: string;
}

interface HelloWithReturn extends IReturn<HelloWithAlternateReturnResponse>
{
    name?: string;
}

// @Route("/helloroute")
interface HelloWithRoute extends IReturn<HelloWithRouteResponse>
{
    name?: string;
}

interface HelloWithType extends IReturn<HelloWithTypeResponse>
{
    name?: string;
}

interface HelloInterface
{
    poco?: IPoco;
    emptyInterface?: IEmptyInterface;
    emptyClass?: EmptyClass;
}

interface HelloInnerTypes extends IReturn<HelloInnerTypesResponse>
{
}

interface HelloBuiltin
{
    dayOfWeek?: DayOfWeek;
}

interface HelloGet extends IReturn<HelloVerbResponse>, IGet
{
    id?: number;
}

interface HelloPost extends HelloBase, IReturn<HelloVerbResponse>, IPost
{
}

interface HelloPut extends IReturn<HelloVerbResponse>, IPut
{
    id?: number;
}

interface HelloDelete extends IReturn<HelloVerbResponse>, IDelete
{
    id?: number;
}

interface HelloPatch extends IReturn<HelloVerbResponse>, IPatch
{
    id?: number;
}

interface HelloReturnVoid extends IReturnVoid
{
    id?: number;
}

interface EnumRequest extends IReturn<EnumResponse>, IPut
{
    operator?: ScopeType;
}

// @Route("/hellozip")
// @DataContract
interface HelloZip extends IReturn<HelloZipResponse>
{
    // @DataMember
    name?: string;

    // @DataMember
    test?: string[];
}

// @Route("/ping")
interface Ping extends IReturn<PingResponse>
{
}

// @Route("/reset-connections")
interface ResetConnections
{
}

// @Route("/requires-role")
interface RequiresRole extends IReturn<RequiresRoleResponse>
{
}

// @Route("/return/string")
interface ReturnString extends IReturn<string>
{
    data?: string;
}

// @Route("/return/bytes")
interface ReturnBytes extends IReturn<Uint8Array>
{
    data?: string;
}

// @Route("/return/stream")
interface ReturnStream extends IReturn<Blob>
{
    data?: string;
}

// @Route("/return/json")
interface ReturnJson
{
}

// @Route("/return/json/header")
interface ReturnJsonHeader
{
}

// @Route("/write/json")
interface WriteJson
{
}

// @Route("/Request1", "GET")
interface GetRequest1 extends IReturn<ReturnedDto[]>, IGet
{
}

// @Route("/Request2", "GET")
interface GetRequest2 extends IReturn<ReturnedDto[]>, IGet
{
}

// @Route("/sendjson")
interface SendJson extends IReturn<string>
{
    id?: number;
    name?: string;
    requestStream?: string;
}

// @Route("/sendtext")
interface SendText extends IReturn<string>
{
    id?: number;
    name?: string;
    contentType?: string;
    requestStream?: string;
}

// @Route("/sendraw")
interface SendRaw extends IReturn<Uint8Array>
{
    id?: number;
    name?: string;
    contentType?: string;
    requestStream?: string;
}

interface SendDefault extends IReturn<SendVerbResponse>
{
    id?: number;
}

// @Route("/sendrestget/{Id}", "GET")
interface SendRestGet extends IReturn<SendVerbResponse>, IGet
{
    id?: number;
}

interface SendGet extends IReturn<SendVerbResponse>, IGet
{
    id?: number;
}

interface SendPost extends IReturn<SendVerbResponse>, IPost
{
    id?: number;
}

interface SendPut extends IReturn<SendVerbResponse>, IPut
{
    id?: number;
}

interface SendReturnVoid extends IReturnVoid
{
    id?: number;
}

// @Route("/session")
interface GetSession extends IReturn<GetSessionResponse>
{
}

// @Route("/session/edit/{CustomName}")
interface UpdateSession extends IReturn<GetSessionResponse>
{
    customName?: string;
}

// @Route("/Stuff")
// @DataContract(Namespace="http://schemas.servicestack.net/types")
interface GetStuff extends IReturn<GetStuffResponse>
{
    // @DataMember
    // @ApiMember(DataType="DateTime", Name="Summary Date")
    summaryDate?: string;

    // @DataMember
    // @ApiMember(DataType="DateTime", Name="Summary End Date")
    summaryEndDate?: string;

    // @DataMember
    // @ApiMember(DataType="string", Name="Symbol")
    symbol?: string;

    // @DataMember
    // @ApiMember(DataType="string", Name="Email")
    email?: string;

    // @DataMember
    // @ApiMember(DataType="bool", Name="Is Enabled")
    isEnabled?: boolean;
}

interface StoreLogs extends IReturn<StoreLogsResponse>
{
    loggers?: Logger[];
}

interface HelloAuth extends IReturn<HelloResponse>
{
    name?: string;
}

// @Route("/testauth")
interface TestAuth extends IReturn<TestAuthResponse>
{
}

// @Route("/testdata/AllTypes")
interface TestDataAllTypes extends IReturn<AllTypes>
{
}

// @Route("/testdata/AllCollectionTypes")
interface TestDataAllCollectionTypes extends IReturn<AllCollectionTypes>
{
}

// @Route("/void-response")
interface TestVoidResponse
{
}

// @Route("/null-response")
interface TestNullResponse
{
}

/** @description Sign In */
// @Route("/auth", "OPTIONS,GET,POST,DELETE")
// @Route("/auth/{provider}", "OPTIONS,GET,POST,DELETE")
// @Api(Description="Sign In")
// @DataContract
interface Authenticate extends IReturn<AuthenticateResponse>, IPost
{
    /** @description AuthProvider, e.g. credentials */
    // @DataMember(Order=1)
    provider?: string;

    // @DataMember(Order=2)
    state?: string;

    // @DataMember(Order=3)
    oauth_token?: string;

    // @DataMember(Order=4)
    oauth_verifier?: string;

    // @DataMember(Order=5)
    userName?: string;

    // @DataMember(Order=6)
    password?: string;

    // @DataMember(Order=7)
    rememberMe?: boolean;

    // @DataMember(Order=9)
    errorView?: string;

    // @DataMember(Order=10)
    nonce?: string;

    // @DataMember(Order=11)
    uri?: string;

    // @DataMember(Order=12)
    response?: string;

    // @DataMember(Order=13)
    qop?: string;

    // @DataMember(Order=14)
    nc?: string;

    // @DataMember(Order=15)
    cnonce?: string;

    // @DataMember(Order=17)
    accessToken?: string;

    // @DataMember(Order=18)
    accessTokenSecret?: string;

    // @DataMember(Order=19)
    scope?: string;

    // @DataMember(Order=20)
    returnUrl?: string;

    // @DataMember(Order=21)
    meta?: { [index: string]: string; };
}

// @Route("/assignroles", "POST")
// @DataContract
interface AssignRoles extends IReturn<AssignRolesResponse>, IPost
{
    // @DataMember(Order=1)
    userName?: string;

    // @DataMember(Order=2)
    permissions?: string[];

    // @DataMember(Order=3)
    roles?: string[];

    // @DataMember(Order=4)
    meta?: { [index: string]: string; };
}

// @Route("/unassignroles", "POST")
// @DataContract
interface UnAssignRoles extends IReturn<UnAssignRolesResponse>, IPost
{
    // @DataMember(Order=1)
    userName?: string;

    // @DataMember(Order=2)
    permissions?: string[];

    // @DataMember(Order=3)
    roles?: string[];

    // @DataMember(Order=4)
    meta?: { [index: string]: string; };
}

/** @description Sign Up */
// @Route("/register", "PUT,POST")
// @Api(Description="Sign Up")
// @DataContract
interface Register extends IReturn<RegisterResponse>, IPost
{
    // @DataMember(Order=1)
    userName?: string;

    // @DataMember(Order=2)
    firstName?: string;

    // @DataMember(Order=3)
    lastName?: string;

    // @DataMember(Order=4)
    displayName?: string;

    // @DataMember(Order=5)
    email?: string;

    // @DataMember(Order=6)
    password?: string;

    // @DataMember(Order=7)
    confirmPassword?: string;

    // @DataMember(Order=8)
    autoLogin?: boolean;

    // @DataMember(Order=10)
    errorView?: string;

    // @DataMember(Order=11)
    meta?: { [index: string]: string; };
}

interface QueryRockstarAudit extends QueryDbTenant_2<RockstarAuditTenant, RockstarAuto>, IReturn<QueryResponse<RockstarAuto>>
{
    id?: number;
}

interface QueryRockstarAuditSubOr extends QueryDb_2<RockstarAuditTenant, RockstarAuto>, IReturn<QueryResponse<RockstarAuto>>
{
    firstNameStartsWith?: string;
    ageOlderThan?: number;
}

interface QueryPocoBase extends QueryDb_1<OnlyDefinedInGenericType>, IReturn<QueryResponse<OnlyDefinedInGenericType>>
{
    id?: number;
}

interface QueryPocoIntoBase extends QueryDb_2<OnlyDefinedInGenericTypeFrom, OnlyDefinedInGenericTypeInto>, IReturn<QueryResponse<OnlyDefinedInGenericTypeInto>>
{
    id?: number;
}

// @Route("/message/query/{Id}", "GET")
interface MessageQuery extends QueryDb_1<MessageQuery>, IReturn<QueryResponse<MessageQuery>>
{
    id?: number;
}

// @Route("/rockstars", "GET")
interface QueryRockstars extends QueryDb_1<Rockstar>, IReturn<QueryResponse<Rockstar>>
{
}

interface CreateRockstarAudit extends RockstarBase, IReturn<RockstarWithIdResponse>, ICreateDb<RockstarAudit>
{
}

interface CreateRockstarAuditTenant extends CreateAuditTenantBase<RockstarAuditTenant, RockstarWithIdAndResultResponse>, IReturn<RockstarWithIdAndResultResponse>, IHasSessionId
{
    sessionId?: string;
    firstName?: string;
    lastName?: string;
    age?: number;
    dateOfBirth?: string;
    dateDied?: string;
    livingStatus?: LivingStatus;
}

interface UpdateRockstarAuditTenant extends UpdateAuditTenantBase<RockstarAuditTenant, RockstarWithIdAndResultResponse>, IReturn<RockstarWithIdAndResultResponse>, IHasSessionId
{
    sessionId?: string;
    id?: number;
    firstName?: string;
    livingStatus?: LivingStatus;
}

interface PatchRockstarAuditTenant extends PatchAuditTenantBase<RockstarAuditTenant, RockstarWithIdAndResultResponse>, IReturn<RockstarWithIdAndResultResponse>, IHasSessionId
{
    sessionId?: string;
    id?: number;
    firstName?: string;
    livingStatus?: LivingStatus;
}

interface SoftDeleteAuditTenant extends SoftDeleteAuditTenantBase<RockstarAuditTenant, RockstarWithIdAndResultResponse>, IReturn<RockstarWithIdAndResultResponse>
{
    id?: number;
}

interface CreateRockstarAuditMqToken extends RockstarBase, IReturn<RockstarWithIdResponse>, ICreateDb<RockstarAudit>, IHasBearerToken
{
    bearerToken?: string;
}

interface RealDeleteAuditTenant extends IReturn<RockstarWithIdAndCountResponse>, IDeleteDb<RockstarAuditTenant>, IHasSessionId
{
    sessionId?: string;
    id?: number;
    age?: number;
}

interface CreateRockstarVersion extends RockstarBase, IReturn<RockstarWithIdAndRowVersionResponse>, ICreateDb<RockstarVersion>
{
}