text:
import Joi = require('joi');

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var x: any = null;
var value: any = null;
var num: number = 0;
var str: string = '';
var bool: boolean = false;
var exp: RegExp = null;
var obj: object = null;
var date: Date = null;
var err: Error = null;
var func: Function = null;

var anyArr: any[] = [];
var numArr: number[] = [];
var strArr: string[] = [];
var boolArr: boolean[] = [];
var expArr: RegExp[] = [];
var objArr: object[] = [];
var errArr: Error[] = [];
var funcArr: Function[] = [];

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var schema: Joi.Schema = null;
var schemaLike: Joi.SchemaLike = null;

var anySchema: Joi.AnySchema = null;
var numSchema: Joi.NumberSchema = null;
var strSchema: Joi.StringSchema = null;
var arrSchema: Joi.ArraySchema = null;
var boolSchema: Joi.BooleanSchema = null;
var binSchema: Joi.BinarySchema = null;
var dateSchema: Joi.DateSchema = null;
var funcSchema: Joi.FunctionSchema = null;
var objSchema: Joi.ObjectSchema = null;
var altSchema: Joi.AlternativesSchema = null;

var schemaArr: Joi.Schema[] = [];

var ref: Joi.Reference = null;
var description: Joi.Description = null;

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var validOpts: Joi.ValidationOptions = null;

validOpts = { abortEarly: bool };
validOpts = { convert: bool };
validOpts = { allowUnknown: bool };
validOpts = { skipFunctions: bool };
validOpts = { stripUnknown: bool };
validOpts = { stripUnknown: { arrays: bool } };
validOpts = { stripUnknown: { objects: bool } };
validOpts = { stripUnknown: { arrays: bool, objects: bool } };
validOpts = { presence: 'optional' || 'required' || 'forbidden' };
validOpts = { context: obj };
validOpts = { noDefaults: bool };
validOpts = {
    language: {
        root: str,
        key: str,
        messages: { wrapArrays: bool },
        string: { base: str },
        number: { base: str },
        object: {
            base: false,
            children: { childRule: str }
        },
        customType: {
            customRule: str
        }
    }
};

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var renOpts: Joi.RenameOptions = null;

renOpts = { alias: bool };
renOpts = { multiple: bool };
renOpts = { override: bool };
renOpts = { ignoreUndefined: bool };

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var emailOpts: Joi.EmailOptions = null;

emailOpts = { errorLevel: num };
emailOpts = { errorLevel: bool };
emailOpts = { tldWhitelist: strArr };
emailOpts = { tldWhitelist: obj };
emailOpts = { minDomainAtoms: num };

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var ipOpts: Joi.IpOptions = null;

ipOpts = { version: str };
ipOpts = { version: strArr };
ipOpts = { cidr: str };

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var uriOpts: Joi.UriOptions = null;

uriOpts = { scheme: str };
uriOpts = { scheme: exp };
uriOpts = { scheme: strArr };
uriOpts = { scheme: expArr };

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var whenOpts: Joi.WhenOptions = null;

whenOpts = { is: x };
whenOpts = { is: schema, then: schema };
whenOpts = { is: schema, otherwise: schema };
whenOpts = { is: schemaLike, then: schemaLike, otherwise: schemaLike };

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var whenSchemaOpts: Joi.WhenSchemaOptions = null;

whenSchemaOpts = { then: schema };
whenSchemaOpts = { otherwise: schema };
whenSchemaOpts = { then: schemaLike, otherwise: schemaLike };

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var refOpts: Joi.ReferenceOptions = null;

refOpts = { separator: str };
refOpts = { contextPrefix: str };

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var validErr: Joi.ValidationError = null;
var validErrItem: Joi.ValidationErrorItem;
var validErrFunc: Joi.ValidationErrorFunction;

validErrItem = {
    message: str,
    type: str,
    path: str
};

validErrItem = {
    message: str,
    type: str,
    path: str,
    options: validOpts,
    context: obj
};

validErrFunc = errs => errs;
validErrFunc = errs => errs[0];
validErrFunc = errs => 'Some error';
validErrFunc = errs => err;

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

schema = anySchema;
schema = numSchema;
schema = strSchema;
schema = arrSchema;
schema = boolSchema;
schema = binSchema;
schema = dateSchema;
schema = funcSchema;
schema = objSchema;

anySchema = anySchema;
anySchema = numSchema;
anySchema = strSchema;
anySchema = arrSchema;
anySchema = boolSchema;
anySchema = binSchema;
anySchema = dateSchema;
anySchema = funcSchema;
anySchema = objSchema;

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

var schemaMap: Joi.SchemaMap = null;

schemaMap = {
    a: numSchema,
    b: strSchema
};
schemaMap = {
    a: numSchema,
    b: {
        b1: strSchema,
        b2: anySchema
    }
};
schemaMap = {
    a: numSchema,
    b: [
        { b1: strSchema },
        { b2: anySchema }
    ],
    c: arrSchema,
    d: schemaLike
};
schemaMap = {
    a: 1,
    b: {
        b1: '1',
        b2: 2
    },
    c: [
        { c1: true },
        { c2: null }
    ]
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

anySchema = Joi.any();

namespace common {
    anySchema = anySchema.allow(x);
    anySchema = anySchema.allow(x, x);
    anySchema = anySchema.allow([x, x, x]);
    anySchema = anySchema.valid(x);
    anySchema = anySchema.valid(x, x);
    anySchema = anySchema.valid([x, x, x]);
    anySchema = anySchema.only(x);
    anySchema = anySchema.only(x, x);
    anySchema = anySchema.only([x, x, x]);
    anySchema = anySchema.equal(x);
    anySchema = anySchema.equal(x, x);
    anySchema = anySchema.equal([x, x, x]);
    anySchema = anySchema.invalid(x);
    anySchema = anySchema.invalid(x, x);
    anySchema = anySchema.invalid([x, x, x]);
    anySchema = anySchema.disallow(x);
    anySchema = anySchema.disallow(x, x);
    anySchema = anySchema.disallow([x, x, x]);
    anySchema = anySchema.not(x);
    anySchema = anySchema.not(x, x);
    anySchema = anySchema.not([x, x, x]);

    anySchema = anySchema.default();
    anySchema = anySchema.default(x);
    anySchema = anySchema.default(x, str);

    anySchema = anySchema.required();
    anySchema = anySchema.optional();
    anySchema = anySchema.forbidden();
    anySchema = anySchema.strip();

    anySchema = anySchema.description(str);
    anySchema = anySchema.notes(str);
    anySchema = anySchema.notes(strArr);
    anySchema = anySchema.tags(str);
    anySchema = anySchema.tags(strArr);

    anySchema = anySchema.meta(obj);
    anySchema = anySchema.example(obj);
    anySchema = anySchema.unit(str);

    anySchema = anySchema.options(validOpts);
    anySchema = anySchema.strict();
    anySchema = anySchema.strict(bool);
    anySchema = anySchema.concat(x);

    altSchema = anySchema.when(str, whenOpts);
    altSchema = anySchema.when(ref, whenOpts);
    altSchema = anySchema.when(schema, whenSchemaOpts);

    anySchema = anySchema.label(str);
    anySchema = anySchema.raw();
    anySchema = anySchema.raw(bool);
    anySchema = anySchema.empty();
    anySchema = anySchema.empty(str);
    anySchema = anySchema.empty(anySchema);

    anySchema = anySchema.error(err);
    anySchema = anySchema.error(validErrFunc);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

arrSchema = Joi.array();

arrSchema = arrSchema.sparse();
arrSchema = arrSchema.sparse(bool);
arrSchema = arrSchema.single();
arrSchema = arrSchema.single(bool);
arrSchema = arrSchema.ordered(anySchema);
arrSchema = arrSchema.ordered(anySchema, numSchema, strSchema, arrSchema, boolSchema, binSchema, dateSchema, funcSchema, objSchema, schemaLike);
arrSchema = arrSchema.ordered(schemaMap);
arrSchema = arrSchema.ordered([schemaMap, schemaMap, schemaLike]);
arrSchema = arrSchema.min(num);
arrSchema = arrSchema.max(num);
arrSchema = arrSchema.length(num);
arrSchema = arrSchema.unique();
arrSchema = arrSchema.unique((a, b) => a.test === b.test);
arrSchema = arrSchema.unique('customer.id');

arrSchema = arrSchema.items(numSchema);
arrSchema = arrSchema.items(numSchema, strSchema, schemaLike);
arrSchema = arrSchema.items([numSchema, strSchema, schemaLike]);
arrSchema = arrSchema.items(schemaMap);
arrSchema = arrSchema.items(schemaMap, schemaMap, schemaLike);
arrSchema = arrSchema.items([schemaMap, schemaMap, schemaLike]);

// - - - - - - - -

namespace common_copy_paste {
    // use search & replace from any
    arrSchema = arrSchema.allow(x);
    arrSchema = arrSchema.allow(x, x);
    arrSchema = arrSchema.allow([x, x, x]);
    arrSchema = arrSchema.valid(x);
    arrSchema = arrSchema.valid(x, x);
    arrSchema = arrSchema.valid([x, x, x]);
    arrSchema = arrSchema.only(x);
    arrSchema = arrSchema.only(x, x);
    arrSchema = arrSchema.only([x, x, x]);
    arrSchema = arrSchema.equal(x);
    arrSchema = arrSchema.equal(x, x);
    arrSchema = arrSchema.equal([x, x, x]);
    arrSchema = arrSchema.invalid(x);
    arrSchema = arrSchema.invalid(x, x);
    arrSchema = arrSchema.invalid([x, x, x]);
    arrSchema = arrSchema.disallow(x);
    arrSchema = arrSchema.disallow(x, x);
    arrSchema = arrSchema.disallow([x, x, x]);
    arrSchema = arrSchema.not(x);
    arrSchema = arrSchema.not(x, x);
    arrSchema = arrSchema.not([x, x, x]);

    arrSchema = arrSchema.default(x);

    arrSchema = arrSchema.required();
    arrSchema = arrSchema.optional();
    arrSchema = arrSchema.forbidden();

    arrSchema = arrSchema.description(str);
    arrSchema = arrSchema.notes(str);
    arrSchema = arrSchema.notes(strArr);
    arrSchema = arrSchema.tags(str);
    arrSchema = arrSchema.tags(strArr);

    arrSchema = arrSchema.meta(obj);
    arrSchema = arrSchema.example(obj);
    arrSchema = arrSchema.unit(str);

    arrSchema = arrSchema.options(validOpts);
    arrSchema = arrSchema.strict();
    arrSchema = arrSchema.concat(x);

    altSchema = arrSchema.when(str, whenOpts);
    altSchema = arrSchema.when(ref, whenOpts);
    altSchema = arrSchema.when(schema, whenSchemaOpts);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

boolSchema = Joi.bool();
boolSchema = Joi.boolean();

namespace common_copy_paste {
    boolSchema = boolSchema.allow(x);
    boolSchema = boolSchema.allow(x, x);
    boolSchema = boolSchema.allow([x, x, x]);
    boolSchema = boolSchema.valid(x);
    boolSchema = boolSchema.valid(x, x);
    boolSchema = boolSchema.valid([x, x, x]);
    boolSchema = boolSchema.only(x);
    boolSchema = boolSchema.only(x, x);
    boolSchema = boolSchema.only([x, x, x]);
    boolSchema = boolSchema.equal(x);
    boolSchema = boolSchema.equal(x, x);
    boolSchema = boolSchema.equal([x, x, x]);
    boolSchema = boolSchema.invalid(x);
    boolSchema = boolSchema.invalid(x, x);
    boolSchema = boolSchema.invalid([x, x, x]);
    boolSchema = boolSchema.disallow(x);
    boolSchema = boolSchema.disallow(x, x);
    boolSchema = boolSchema.disallow([x, x, x]);
    boolSchema = boolSchema.not(x);
    boolSchema = boolSchema.not(x, x);
    boolSchema = boolSchema.not([x, x, x]);

    boolSchema = boolSchema.default(x);

    boolSchema = boolSchema.required();
    boolSchema = boolSchema.optional();
    boolSchema = boolSchema.forbidden();

    boolSchema = boolSchema.description(str);
    boolSchema = boolSchema.notes(str);
    boolSchema = boolSchema.notes(strArr);
    boolSchema = boolSchema.tags(str);
    boolSchema = boolSchema.tags(strArr);

    boolSchema = boolSchema.meta(obj);
    boolSchema = boolSchema.example(obj);
    boolSchema = boolSchema.unit(str);

    boolSchema = boolSchema.options(validOpts);
    boolSchema = boolSchema.strict();
    boolSchema = boolSchema.concat(x);

    boolSchema = boolSchema.truthy(str);
    boolSchema = boolSchema.truthy(num);
    boolSchema = boolSchema.truthy(strArr);
    boolSchema = boolSchema.truthy(numArr);
    boolSchema = boolSchema.truthy(str, str);
    boolSchema = boolSchema.truthy(strArr, str);
    boolSchema = boolSchema.truthy(str, strArr);
    boolSchema = boolSchema.truthy(strArr, strArr);
    boolSchema = boolSchema.falsy(str);
    boolSchema = boolSchema.falsy(num);
    boolSchema = boolSchema.falsy(strArr);
    boolSchema = boolSchema.falsy(numArr);
    boolSchema = boolSchema.falsy(str, str);
    boolSchema = boolSchema.falsy(strArr, str);
    boolSchema = boolSchema.falsy(str, strArr);
    boolSchema = boolSchema.falsy(strArr, strArr);
    boolSchema = boolSchema.insensitive(bool);

    altSchema = boolSchema.when(str, whenOpts);
    altSchema = boolSchema.when(ref, whenOpts);
    altSchema = boolSchema.when(schema, whenSchemaOpts);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

binSchema = Joi.binary();

binSchema = binSchema.encoding(str);
binSchema = binSchema.min(num);
binSchema = binSchema.max(num);
binSchema = binSchema.length(num);

namespace common {
    binSchema = binSchema.allow(x);
    binSchema = binSchema.allow(x, x);
    binSchema = binSchema.allow([x, x, x]);
    binSchema = binSchema.valid(x);
    binSchema = binSchema.valid(x, x);
    binSchema = binSchema.valid([x, x, x]);
    binSchema = binSchema.only(x);
    binSchema = binSchema.only(x, x);
    binSchema = binSchema.only([x, x, x]);
    binSchema = binSchema.equal(x);
    binSchema = binSchema.equal(x, x);
    binSchema = binSchema.equal([x, x, x]);
    binSchema = binSchema.invalid(x);
    binSchema = binSchema.invalid(x, x);
    binSchema = binSchema.invalid([x, x, x]);
    binSchema = binSchema.disallow(x);
    binSchema = binSchema.disallow(x, x);
    binSchema = binSchema.disallow([x, x, x]);
    binSchema = binSchema.not(x);
    binSchema = binSchema.not(x, x);
    binSchema = binSchema.not([x, x, x]);

    binSchema = binSchema.default(x);

    binSchema = binSchema.required();
    binSchema = binSchema.optional();
    binSchema = binSchema.forbidden();

    binSchema = binSchema.description(str);
    binSchema = binSchema.notes(str);
    binSchema = binSchema.notes(strArr);
    binSchema = binSchema.tags(str);
    binSchema = binSchema.tags(strArr);

    binSchema = binSchema.meta(obj);
    binSchema = binSchema.example(obj);
    binSchema = binSchema.unit(str);

    binSchema = binSchema.options(validOpts);
    binSchema = binSchema.strict();
    binSchema = binSchema.concat(x);

    altSchema = binSchema.when(str, whenOpts);
    altSchema = binSchema.when(ref, whenOpts);
    altSchema = binSchema.when(schema, whenSchemaOpts);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

dateSchema = Joi.date();

dateSchema = dateSchema.min(date);
dateSchema = dateSchema.max(date);

dateSchema = dateSchema.min(str);
dateSchema = dateSchema.max(str);

dateSchema = dateSchema.min(num);
dateSchema = dateSchema.max(num);

dateSchema = dateSchema.min(ref);
dateSchema = dateSchema.max(ref);

dateSchema = dateSchema.format(str);
dateSchema = dateSchema.format(strArr);

dateSchema = dateSchema.iso();

dateSchema = dateSchema.timestamp();
dateSchema = dateSchema.timestamp('javascript');
dateSchema = dateSchema.timestamp('unix');

namespace common {
    dateSchema = dateSchema.allow(x);
    dateSchema = dateSchema.allow(x, x);
    dateSchema = dateSchema.allow([x, x, x]);
    dateSchema = dateSchema.valid(x);
    dateSchema = dateSchema.valid(x, x);
    dateSchema = dateSchema.valid([x, x, x]);
    dateSchema = dateSchema.only(x);
    dateSchema = dateSchema.only(x, x);
    dateSchema = dateSchema.only([x, x, x]);
    dateSchema = dateSchema.equal(x);
    dateSchema = dateSchema.equal(x, x);
    dateSchema = dateSchema.equal([x, x, x]);
    dateSchema = dateSchema.invalid(x);
    dateSchema = dateSchema.invalid(x, x);
    dateSchema = dateSchema.invalid([x, x, x]);
    dateSchema = dateSchema.disallow(x);
    dateSchema = dateSchema.disallow(x, x);
    dateSchema = dateSchema.disallow([x, x, x]);
    dateSchema = dateSchema.not(x);
    dateSchema = dateSchema.not(x, x);
    dateSchema = dateSchema.not([x, x, x]);

    dateSchema = dateSchema.default(x);

    dateSchema = dateSchema.required();
    dateSchema = dateSchema.optional();
    dateSchema = dateSchema.forbidden();

    dateSchema = dateSchema.description(str);
    dateSchema = dateSchema.notes(str);
    dateSchema = dateSchema.notes(strArr);
    dateSchema = dateSchema.tags(str);
    dateSchema = dateSchema.tags(strArr);

    dateSchema = dateSchema.meta(obj);
    dateSchema = dateSchema.example(obj);
    dateSchema = dateSchema.unit(str);

    dateSchema = dateSchema.options(validOpts);
    dateSchema = dateSchema.strict();
    dateSchema = dateSchema.concat(x);

    altSchema = dateSchema.when(str, whenOpts);
    altSchema = dateSchema.when(ref, whenOpts);
    altSchema = dateSchema.when(schema, whenSchemaOpts);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

funcSchema = Joi.func();

funcSchema = funcSchema.arity(num);
funcSchema = funcSchema.minArity(num);
funcSchema = funcSchema.maxArity(num);
funcSchema = funcSchema.ref();

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

numSchema = Joi.number();

numSchema = numSchema.min(num);
numSchema = numSchema.min(ref);
numSchema = numSchema.max(num);
numSchema = numSchema.max(ref);
numSchema = numSchema.greater(num);
numSchema = numSchema.greater(ref);
numSchema = numSchema.less(num);
numSchema = numSchema.less(ref);
numSchema = numSchema.integer();
numSchema = numSchema.precision(num);
numSchema = numSchema.multiple(num);
numSchema = numSchema.positive();
numSchema = numSchema.negative();

namespace common {
    numSchema = numSchema.allow(x);
    numSchema = numSchema.allow(x, x);
    numSchema = numSchema.allow([x, x, x]);
    numSchema = numSchema.valid(x);
    numSchema = numSchema.valid(x, x);
    numSchema = numSchema.valid([x, x, x]);
    numSchema = numSchema.only(x);
    numSchema = numSchema.only(x, x);
    numSchema = numSchema.only([x, x, x]);
    numSchema = numSchema.equal(x);
    numSchema = numSchema.equal(x, x);
    numSchema = numSchema.equal([x, x, x]);
    numSchema = numSchema.invalid(x);
    numSchema = numSchema.invalid(x, x);
    numSchema = numSchema.invalid([x, x, x]);
    numSchema = numSchema.disallow(x);
    numSchema = numSchema.disallow(x, x);
    numSchema = numSchema.disallow([x, x, x]);
    numSchema = numSchema.not(x);
    numSchema = numSchema.not(x, x);
    numSchema = numSchema.not([x, x, x]);

    numSchema = numSchema.default(x);

    numSchema = numSchema.required();
    numSchema = numSchema.optional();
    numSchema = numSchema.forbidden();

    numSchema = numSchema.description(str);
    numSchema = numSchema.notes(str);
    numSchema = numSchema.notes(strArr);
    numSchema = numSchema.tags(str);
    numSchema = numSchema.tags(strArr);

    numSchema = numSchema.meta(obj);
    numSchema = numSchema.example(obj);
    numSchema = numSchema.unit(str);

    numSchema = numSchema.options(validOpts);
    numSchema = numSchema.strict();
    numSchema = numSchema.concat(x);

    altSchema = numSchema.when(str, whenOpts);
    altSchema = numSchema.when(ref, whenOpts);
    altSchema = numSchema.when(schema, whenSchemaOpts);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

objSchema = Joi.object();
objSchema = Joi.object(schemaMap);

objSchema = objSchema.keys();
objSchema = objSchema.keys(schemaMap);

objSchema = objSchema.min(num);
objSchema = objSchema.max(num);
objSchema = objSchema.length(num);

objSchema = objSchema.pattern(exp, schema);
objSchema = objSchema.pattern(exp, schemaLike);

objSchema = objSchema.and(str);
objSchema = objSchema.and(str, str);
objSchema = objSchema.and(str, str, str);
objSchema = objSchema.and(strArr);

objSchema = objSchema.nand(str);
objSchema = objSchema.nand(str, str);
objSchema = objSchema.nand(str, str, str);
objSchema = objSchema.nand(strArr);

objSchema = objSchema.or(str);
objSchema = objSchema.or(str, str);
objSchema = objSchema.or(str, str, str);
objSchema = objSchema.or(strArr);

objSchema = objSchema.xor(str);
objSchema = objSchema.xor(str, str);
objSchema = objSchema.xor(str, str, str);
objSchema = objSchema.xor(strArr);

objSchema = objSchema.with(str, str);
objSchema = objSchema.with(str, strArr);

objSchema = objSchema.without(str, str);
objSchema = objSchema.without(str, strArr);

objSchema = objSchema.rename(str, str);
objSchema = objSchema.rename(str, str, renOpts);

objSchema = objSchema.assert(str, schema);
objSchema = objSchema.assert(str, schema, str);
objSchema = objSchema.assert(ref, schema);
objSchema = objSchema.assert(ref, schema, str);

objSchema = objSchema.unknown();
objSchema = objSchema.unknown(bool);

objSchema = objSchema.type(func);
objSchema = objSchema.type(func, str);

objSchema = objSchema.requiredKeys(str);
objSchema = objSchema.requiredKeys(str, str);
objSchema = objSchema.requiredKeys(strArr);

objSchema = objSchema.optionalKeys(str);
objSchema = objSchema.optionalKeys(str, str);
objSchema = objSchema.optionalKeys(strArr);

namespace common {
    objSchema = objSchema.allow(x);
    objSchema = objSchema.allow(x, x);
    objSchema = objSchema.allow([x, x, x]);
    objSchema = objSchema.valid(x);
    objSchema = objSchema.valid(x, x);
    objSchema = objSchema.valid([x, x, x]);
    objSchema = objSchema.only(x);
    objSchema = objSchema.only(x, x);
    objSchema = objSchema.only([x, x, x]);
    objSchema = objSchema.equal(x);
    objSchema = objSchema.equal(x, x);
    objSchema = objSchema.equal([x, x, x]);
    objSchema = objSchema.invalid(x);
    objSchema = objSchema.invalid(x, x);
    objSchema = objSchema.invalid([x, x, x]);
    objSchema = objSchema.disallow(x);
    objSchema = objSchema.disallow(x, x);
    objSchema = objSchema.disallow([x, x, x]);
    objSchema = objSchema.not(x);
    objSchema = objSchema.not(x, x);
    objSchema = objSchema.not([x, x, x]);

    objSchema = objSchema.default(x);

    objSchema = objSchema.required();
    objSchema = objSchema.optional();
    objSchema = objSchema.forbidden();

    objSchema = objSchema.description(str);
    objSchema = objSchema.notes(str);
    objSchema = objSchema.notes(strArr);
    objSchema = objSchema.tags(str);
    objSchema = objSchema.tags(strArr);

    objSchema = objSchema.meta(obj);
    objSchema = objSchema.example(obj);
    objSchema = objSchema.unit(str);

    objSchema = objSchema.options(validOpts);
    objSchema = objSchema.strict();
    objSchema = objSchema.concat(x);

    altSchema = objSchema.when(str, whenOpts);
    altSchema = objSchema.when(ref, whenOpts);
    altSchema = objSchema.when(schema, whenSchemaOpts);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

strSchema = Joi.string();

strSchema = strSchema.insensitive();
strSchema = strSchema.min(num);
strSchema = strSchema.min(num, str);
strSchema = strSchema.min(ref);
strSchema = strSchema.min(ref, str);
strSchema = strSchema.max(num);
strSchema = strSchema.max(num, str);
strSchema = strSchema.max(ref);
strSchema = strSchema.max(ref, str);
strSchema = strSchema.creditCard();
strSchema = strSchema.length(num);
strSchema = strSchema.length(num, str);
strSchema = strSchema.length(ref);
strSchema = strSchema.length(ref, str);
strSchema = strSchema.regex(exp);
strSchema = strSchema.regex(exp, str);
strSchema = strSchema.replace(exp, str);
strSchema = strSchema.replace(str, str);
strSchema = strSchema.alphanum();
strSchema = strSchema.token();
strSchema = strSchema.email();
strSchema = strSchema.email(emailOpts);
strSchema = strSchema.ip();
strSchema = strSchema.ip(ipOpts);
strSchema = strSchema.uri();
strSchema = strSchema.uri(uriOpts);
strSchema = strSchema.guid();
strSchema = strSchema.guid({ version: ['uuidv1', 'uuidv2', 'uuidv3', 'uuidv4', 'uuidv5'] } as Joi.GuidOptions);
strSchema = strSchema.guid({ version: 'uuidv4' });
strSchema = strSchema.hex();
strSchema = strSchema.hostname();
strSchema = strSchema.isoDate();
strSchema = strSchema.lowercase();
strSchema = strSchema.uppercase();
strSchema = strSchema.trim();
strSchema = strSchema.truncate();
strSchema = strSchema.truncate(false);
strSchema = strSchema.normalize();
strSchema = strSchema.normalize('NFKC');

namespace common {
    strSchema = strSchema.allow(x);
    strSchema = strSchema.allow(x, x);
    strSchema = strSchema.allow([x, x, x]);
    strSchema = strSchema.valid(x);
    strSchema = strSchema.valid(x, x);
    strSchema = strSchema.valid([x, x, x]);
    strSchema = strSchema.only(x);
    strSchema = strSchema.only(x, x);
    strSchema = strSchema.only([x, x, x]);
    strSchema = strSchema.equal(x);
    strSchema = strSchema.equal(x, x);
    strSchema = strSchema.equal([x, x, x]);
    strSchema = strSchema.invalid(x);
    strSchema = strSchema.invalid(x, x);
    strSchema = strSchema.invalid([x, x, x]);
    strSchema = strSchema.disallow(x);
    strSchema = strSchema.disallow(x, x);
    strSchema = strSchema.disallow([x, x, x]);
    strSchema = strSchema.not(x);
    strSchema = strSchema.not(x, x);
    strSchema = strSchema.not([x, x, x]);

    strSchema = strSchema.default(x);

    strSchema = strSchema.required();
    strSchema = strSchema.optional();
    strSchema = strSchema.forbidden();

    strSchema = strSchema.description(str);
    strSchema = strSchema.notes(str);
    strSchema = strSchema.notes(strArr);
    strSchema = strSchema.tags(str);
    strSchema = strSchema.tags(strArr);

    strSchema = strSchema.meta(obj);
    strSchema = strSchema.example(obj);
    strSchema = strSchema.unit(str);

    strSchema = strSchema.options(validOpts);
    strSchema = strSchema.strict();
    strSchema = strSchema.concat(x);

    altSchema = strSchema.when(str, whenOpts);
    altSchema = strSchema.when(ref, whenOpts);
    altSchema = strSchema.when(schema, whenSchemaOpts);
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

schema = Joi.alternatives();
schema = Joi.alternatives().try(schemaArr);
schema = Joi.alternatives().try(schema, schema);

schema = Joi.alternatives(schemaArr);
schema = Joi.alternatives(schema, anySchema, boolSchema);

schema = Joi.alt();
schema = Joi.alt().try(schemaArr);
schema = Joi.alt().try(schema, schema);

schema = Joi.alt(schemaArr);
schema = Joi.alt(schema, anySchema, boolSchema);

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

schema = Joi.lazy(() => schema)

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

namespace validate_tests {
    {
        Joi.validate(value, obj);
        Joi.validate(value, schema);
        Joi.validate(value, schema, validOpts);
        Joi.validate(value, schema, validOpts, (err, value) => {
            x = value;
            str = err.message;
            str = err.details[0].path;
            str = err.details[0].message;
            str = err.details[0].type;
        });
        Joi.validate(value, schema, (err, value) => {
            x = value;
            str = err.message;
            str = err.details[0].path;
            str = err.details[0].message;
            str = err.details[0].type;
        });
        // variant
        Joi.validate(num, schema, validOpts, (err, value) => {
            num = value;
        });

        // plain opts
        Joi.validate(value, {});
    }

    {
        let value = { username: 'example', password: 'example' };
        let schema = Joi.object().keys({
            username: Joi.string().max(255).required(),
            password: Joi.string().regex(/^[a-zA-Z0-9]{3,255}$/).required(),
        });
        let returnValue: Joi.ValidationResult<typeof value>;

        returnValue = schema.validate(value);
        value = schema.validate(value, (err, value) => value);

        returnValue = Joi.validate(value, schema);
        returnValue = Joi.validate(value, obj);
        value = Joi.validate(value, obj, (err, value) => value);
        value = Joi.validate(value, schema, (err, value) => value);

        returnValue = Joi.validate(value, schema, validOpts);
        returnValue = Joi.validate(value, obj, validOpts);
        value = Joi.validate(value, obj, validOpts, (err, value) => value);
        value = Joi.validate(value, schema, validOpts, (err, value) => value);

        returnValue = schema.validate(value);
        returnValue = schema.validate(value, validOpts);
        value = schema.validate(value, (err, value) => value);
        value = schema.validate(value, validOpts, (err, value) => value);
    }
}

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

schema = Joi.compile(obj);
schema = Joi.compile(schemaMap);

Joi.assert(obj, schema);
Joi.assert(obj, schema, str);
Joi.assert(obj, schema, err);
Joi.assert(obj, schemaLike);

Joi.attempt(obj, schema);
Joi.attempt(obj, schema, str);
Joi.attempt(obj, schema, err);
Joi.attempt(obj, schemaLike);

ref = Joi.ref(str, refOpts);
ref = Joi.ref(str);

Joi.isRef(ref);

description = Joi.describe(schema);
description = schema.describe();

schema = Joi.reach(objSchema, '');

const Joi2 = Joi.extend({ name: '', base: schema });

const Joi3 = Joi.extend({
    base: Joi.string(),
    name: 'string',
    language: {
        asd: 'must be exactly asd(f)',
    },
    pre(value, state, options) {
        return value;
    },
    describe(description) {
        return description;
    },
    rules: [
        {
            name: 'asd',
            params: {
                allowF: Joi.boolean().default(false),
            },
            setup(params) {
                const fIsAllowed = params.allowF;
            },
            validate(params, value, state, options) {
                if (value === 'asd' || params.allowF && value === 'asdf') {
                    return value;
                }
                return this.createError('asd', { v: value }, state, options);
            },
        },
    ],
});

// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---

schema = Joi.allow(x, x);
schema = Joi.allow([x, x, x]);
schema = Joi.valid(x);
schema = Joi.valid(x, x);
schema = Joi.valid([x, x, x]);
schema = Joi.only(x);
schema = Joi.only(x, x);
schema = Joi.only([x, x, x]);
schema = Joi.equal(x);
schema = Joi.equal(x, x);
schema = Joi.equal([x, x, x]);
schema = Joi.invalid(x);
schema = Joi.invalid(x, x);
schema = Joi.invalid([x, x, x]);
schema = Joi.disallow(x);
schema = Joi.disallow(x, x);
schema = Joi.disallow([x, x, x]);
schema = Joi.not(x);
schema = Joi.not(x, x);
schema = Joi.not([x, x, x]);

schema = Joi.required();
schema = Joi.optional();
schema = Joi.forbidden();
schema = Joi.strip();

schema = Joi.description(str);
schema = Joi.notes(str);
schema = Joi.notes(strArr);
schema = Joi.tags(str);
schema = Joi.tags(strArr);

schema = Joi.meta(obj);
schema = Joi.example(obj);
schema = Joi.unit(str);

schema = Joi.options(validOpts);
schema = Joi.strict();
schema = Joi.strict(bool);
schema = Joi.concat(x);

schema = Joi.when(str, whenOpts);
schema = Joi.when(ref, whenOpts);
schema = Joi.when(schema, whenSchemaOpts);

schema = Joi.label(str);
schema = Joi.raw();
schema = Joi.raw(bool);
schema = Joi.empty();
schema = Joi.empty(str);
schema = Joi.empty(anySchema);

redpajama_set_name: RedPajamaGithub


text:
Q: How to normalize tags table I had table like this:
post:
+----------------+-----------+
| article_id     | tags      |
+----------------+-----------+
| 1              |  x1,x2,x3|
| 2              |  x1,x4,x5 |
+----------------+-----------+

what i am trying to do is to normalize it, so i create 2 more tables:
tags:
+----------------+-----------+
| tag_id         | tag_name  |
+----------------+-----------+
| 1              |    x1     |
| 2              |    x2     |
| 3              |    x3     |
+----------------+-----------+

post_tag:
+----------------+-----------+
| id_post         | id_tag  |
+----------------+-----------+
| 1              |    1     |
| 1              |    2     |
| 2              |    1     |
+----------------+-----------+

I have exported all tags from post table to tags table and now each tag has his own id in tags table, but I am so confused when i am thinking how to do it with post_tag table?
edit: questin is how to populate post_tag table, how the query would look like?
tried like this
$sql=mysql_query("SELECT * FROM post");
    while($row=mysql_fetch_array($sql)) {
        $article_id=$row['article_id'];
  $all_tags =$row['tags'];
  $tags= explode(",",$all_tags);
    foreach($all_tags as $tag) {
     $sql2=mysql_query("SELECT * FROM tags WHERE tag_name = '$tag'");
      while($row=mysql_fetch_array($sql2)) {                               $tag_id=$row['tag_id'];                                  $q = "INSERT INTO post_tag (id_post, id_tag) VALUE ('$article_id', $tag_id')";
        $r = mysql_query($q);
      }
    }
}

but it doesn't write complete post_tag table

A: For every tag a post has, you insert an entry in the post_tag table. It's called an m-to-n relationship. Google it ;)

*

*post_id: 1, tag_id: 1

*post_id: 1, tag_id: 2

*post_id: 1, tag_id: 3

post

*

*post_id

tag

*

*tag_id

*tag_name

post_tag

*

*post_id

*tag_id

A: I see, you want to solve your issue with one sql-query, but it's not convenient. Try to use php-power and you'll succeed.
The php way.
1. Create tables tags and posts_tags (like you described in the question).
2. In php get all rows from your current post table and loop it:
foreach($query_results as $row) {
  $article_id = $row['article_id];
  $tags = explode('|', $row['tags']);
  foreach($tags as $tag) {
    // here check if this tag exists in your new `tags` table (by tag's name). If it is, save its id in $tag_id variable.
    // if a tag don't exists then insert it. And put its new id (mysql returns it after inserting) into $tag_id.
    // After that add a row ($article_id, $tag_id) to table `posts_tags`
  }
}

Then delete column tags from old post table. Profit!
p.s. Create unique indexes on tag's name in tags table and on pair (article_id, tag_id) in posts_tags table.

A: Maybe this one will work?
$sql= mysql_query("SELECT * FROM post");
while($row=mysql_fetch_array($sql)) {
    $article_id=$row['article_id'];
    $all_tags = $row['tags'];
    $tags = explode(",",$all_tags);
    foreach($all_tags as $tag_title) {
        $tag_id = null;
        $tag=mysql_fetch_assoc(mysql_query('SELECT * FROM tags WHERE tag_name = "'.$tag_title.'"'));
        if ($tag) {
            $tag_id = $tag['tag_id'];
        } else {
            mysql_query('INSERT INTO tags SET tag_name = "'.$tag_title.'"');
            $tag_id = mysql_insert_id();
        }
        $q = "INSERT INTO post_tag (id_post, id_tag) VALUE ('$article_id', $tag_id')";
        $r = mysql_query($q);
    }
}

After running the loop, you will need to drop the old column in post table

A: Say you have a post called my cat!, and it has an id of 1. You wish to add the tags cats and home to it.
You should first create the tags cats and home in the tags table, if they don't already exist. lets say they are cats | 2 and home | 4 (the number is their id).
You then need to store in the post_tag table the values 1 | 2 and 1 | 4, where the first value is the post's id, and the second value is the tag's id.
To find tags for post number 1, you'd want something like
SELECT Tags.name FROM Tags, Tags_Posts WHERE Tags_Posts.post_id = 1 AND Tags.id = Tags_Posts.tag_id

redpajama_set_name: RedPajamaStackExchange


text:
SFS Ventures acquires a controlling interest in Polish radio company Eurozet
Prague, February 20, 2019: SFS Ventures s.r.o. today announced that it has acquired 60% of the share capital of Polish radio company Eurozet sp. z o.o. from Czech Media Invest.
MDIF launches private equity impact fund for independent media
New York, February 7, 2019: As illiberal democracies advance around the world and even digital darlings like Buzzfeed, HuffPost and Vice announce lay-offs, a new approach to investing in impactful…
Montenegro's Vijesti suffers cyberattacks and fears violence
Montenegro's independent news portal Vijesti has suffered a series of cyberattacks amid fears of renewed violence, as President Milo Djukanovic ramps up his campaign against critical media. The Vijesti portal…
SAMIP rounds off the year with a bang
In South Africa, the weeks before Christmas are punctuated with fireworks during Diwali, the festival of lights celebrated by the local Hindi population, and Guy Fawkes, a British celebration that…
Somali journalist shot at by police officer
An unidentified police officer fired several shots at close range at Ahmed Sheikh Mohamed, Director-General of Radio Daljir in the city of Bossasso in the semi-autonomous region of Puntland…
MAS publishes media management guide to podcasting
Media Advisory Services has published a guide to podcasting, the fifth in its series of publications on important aspects of media management. Read or download it here. The…
MAS holds training on native advertising and digital media
Media Advisory Services (MAS), MDIF's technical assistance division, held two major training events on native advertising and digital media in November. In line with our strategy of holding training around…
MDIF publishes Myanmar local media business report
New York, 6 November 2018: Media Development Investment Fund today published An Unfavorable Business: Running Local Media in Myanmar's Ethnic States and Regions, a 66- page…
MDIF clients reach 93.7 million people, a record high
Last year, 93.7 million people received their news from MDIF clients, a record high in MDIF's 22 years of work. From a network of radio stations in Somalia to…

redpajama_set_name: RedPajamaCommonCrawl


text:
Browse 1 results
Canadian Armed Forces Operation Recuperation fonds
Canada. Canadian Armed Forces
French » Canada. Forces armées canadiennes
Type of entity
Corporate body
Authorized form of name
Parallel form(s) of name
Standardized form(s) of name according to other rules
Other form(s) of name
Identifiers for corporate bodies
Description area
Dates of existence
The Canadian Forces (CF), officially the Canadian Armed Forces are the unified armed forces of Canada, as constituted by the National Defence Act. This singular institution consists of three main branches: Maritime Command (MARCOM), Land Force Command (LFC), and Air Command (AIRCOM), which are together overseen by the Armed Forces Council, chaired by the Chief of the Defence Staff. At the pinnacle of the command structure is the Commander-in-Chief, who is the reigning Canadian monarch, Queen Elizabeth II, represented by the Governor General. The current incarnation of the Canadian Forces dates from 1 February 1968, when the Royal Canadian Navy, Canadian Army, and Royal Canadian Air Force were merged into a unified structure. The forces are today funded by approximately $20 billion annually [4] ranked 16th, and are presently ranked 74th in size compared to the world's other armed forces by number of total personnel, and 58th in terms of active personnel, standing at a population of roughly 66,000, not including the 26,000 reservists.[2] These individuals serve on numerous CF bases located in all regions of the country, and are governed by the Queen's Regulations and Orders and the National Defence Act.
Functions, occupations and activities
Mandates/sources of authority
Internal structures/genealogy
General context
Relationships area
Access points area
Control area
Authority record identifier
Dates of creation, revision and deletion


text:
Utah Names Official State Firearm
Updated Apr. 24, 2017 4:22PM ET / Published Mar. 18, 2011 5:44PM ET
Too soon? In a head-scratching move, Utah's 24 existing state symbols—a blue spruce tree, honeybee, and Dutch oven among then—will now be joined by an official state firearm: the John M. Browning-designed M1911 pistol. Yes, Utah has become the first state in the nation to boast an official state firearm, says Utah Gov. Gary Herbert, who signed the new symbol into law this week. Herbert chose this particular firearm because the gun maker, Browning, was born and raised in Ogden, Utah. The move has raised controversy since it was pushed through even after January's gun rampage in Tucson, Arizona, which killed six and wounded 13 others, including U.S. Rep. Gabrielle Giffords. "People say the timing is terrible, and I admit the timing is terrible," said Utah State Rep. Carl Wimmer, a Republican. "We have a part-time legislature in Utah, and we are only in session for 45 days. Certainly meaning no disrespect to the tragedy in Arizona, we moved forward in doing this because it's the only opportunity that we had."
Read it at CNN


You can listen on your favorite app and subscribe to the show!
Here we are on YouTube.
Or, for those tech-y types, our direct RSS feed.
Want to receive occasional updates about the show? We'll send you an email about once per month.


text:
OPINION: The countryside has the best possibilities for creating a new life in Sweden
Life in rural Sweden may have its drawbacks, but the countryside is more welcoming towards immigrants than many people think, writes Ariz Kader in this opinion piece.
Published: 30 July 2021 11:55 CEST
Life in the Swedish countryside is starkly different to life in the city, writes Ariz Kader. Photo: Private
On July 27th, I wrote a short Twitter thread documenting my experiences as an immigrant to Sweden. The thread contrasted my experiences growing up in an immigrant-heavy suburb of Stockholm with my current life in the Swedish countryside and included my thoughts on what this could mean for integration into either community. As the thread seemed to gain a lot of traction online and was widely discussed, the staff at The Local have been kind enough to ask me to write a version of the thread for their publication. Some of the text has been altered for clarity's sake.
I lived in Stockholm for about 14 years in my childhood and teenage years, and in retrospect, I can't think of a more segregated experience. Echoing a lot of my friends of the same generation (first generation of immigrants) – to a certain extent – it feels as if the generation that were born here in the suburbs speak Swedish less fluently than we did. To me, this seems natural as it reflects the concentration of non-native speakers creating their own dialect, rather than learning established ones from native speakers.
Schools in these areas also suffered growing up. Many teachers preferred not to be assigned there and kids from troubled backgrounds made teaching difficult for everyone. This was the case in my school as well.
In Sweden, there is a pedagogical culture of parent involvement in teaching with parents being involved heavily in school meetings, collaborating with teachers, and actively participating in other activities. With few Swedes around, teachers who worked in our schools later told me that immigrant parents simply didn't pick up these cultural habits.
Shops in these areas also reflected both the kinds of communities that exist with immigrant food shops, cafes, and clothing shops mirroring the diverse background of residents, but you typically also got fewer general stores because those businesses didn't think it was worth the investment to set up shop. This resulted in immigrant suburbs with a good variety of ethnic foods and clothes, but generally not much else, and so limiting the ability of people to have access to jobs locally.
All in all, these areas have a pretty heavy "us vs them" mentality, with immigrants believing the state isn't doing enough to promote good services and investment, while businesses and services refuse to invest because of a real or perceived unsafe environment.
As a kid growing up there, there was an extreme sense of hopelessness. Society was perceived as being against immigrants in general. My first clear memory/experience of speaking to a Swede my age from a non-immigrant background is from when I was 12.
The stark cultural differences between Swedish families and immigrant families also created huge hurdles for understanding and feeling welcome. In my family, if we had unexpected guests, we would simply cook more food. In many Swedish families, though of course not all, you were expected to go home to eat or even stay in your friend's room while the family had dinner.
Many Swedish cities are heavily segregated. Photo: Bertil Ericson/TT
Moving back to Sweden after spending a decade abroad, I settled down in the countryside, and it genuinely felt like I had moved to another country entirely to the one I remember from my childhood years. When we moved in, every single neighbour came to welcome us. We were invited to dinner at everyone's house.
I get questions and comments about my background that may be perceived as a bit naive or even offensive without context, but when you get to know my neighbours, you understand it comes from a genuine desire to know more about where I come from; it's never a wish to offend.
In the city, I often feel prejudices seem to be held to oneself with the effect being obvious segregation with people in affluent suburbs being "anti-racist" while never setting foot in an immigrant-heavy area. In the country, prejudices are there, but are open to change with a conversation.
'In northern Sweden we lock our door to shut out the friendly people'
There are drawbacks, of course. There is little to no access to my traditional foods, nor is there a community of immigrants that might speak my language. My kids will also have a harder time learning my language despite my effort to teach them. But since we live in this country, and since it is their home, I consider that a small price to pay for them growing up as an equal and appreciated part of their community, and not some outsider who will never truly fit in.
This probably boils down to the larger question of what becoming a part of a new country really means. How much do we keep of where we came from if we want to successfully live where we have decided to settle down?
But, in case you really do want to live and be part of the place you decide to call home, I honestly believe the countryside has the best possibilities for creating that new life, and not turning you into a third, fourth, or even fifth generation "immigrant".
Ariz Kader is a research assistant at Uppsala University's Peace and Conflict Research Institute. Follow him on Twitter HERE.
Ariz Kader. Photo: Private
The Local [email protected] @thelocalsweden
RACISMOPINION & ANALYSIS
OPINION: The Franco-German 'couple' is crucial to the EU but the relationship is in trouble
OPINION: Trains are in fashion so why is rail travel across Europe still so difficult?
Down with hygge! Sweden's mys is more real, fun and inclusive
Hygge, the Danish art of getting cosy, has taken the world by storm. But the Swedish equivalent is refreshingly different, says David Crouch
It is around six years since the Danish word hygge entered many of our languages. Hygge, pronounced hue-guh and generally translated as the art of cosiness, exploded almost overnight to become a global lifestyle phenomenon.
Hygge dovetailed with mindfulness and fed into other popular trends such as healthy eating, and even adult colouring books. "The Little Book of Hygge" became a publishing sensation and has been translated into 15 languages. In time for Christmas, its author has just issued a second book, "My Hygge Home", one of dozens already on the market. This is the season of peak hygge, of candles, log fires, cups of cocoa and comforting music.
There is nothing wrong with new ways to relax, and certainly no harm in identifying them with Scandinavia. But as a guide to living your life, there are some problems with hygge.
First, the original meaning of the word is too broad and subtle to enable a clear grasp of the concept among non-Danes. This probably helps to explain its appeal – hygge is an empty bottle into which you can pour whatever liquid you like.
Patrick Kingsley, who wrote a book about Denmark several years before the hygge hype, was "surprised to hear people describe all sorts of things" as hygge. Danes, he said, would use the word when talking about a bicycle, a table, or even an afternoon stroll.
So it is hardly surprising that, outside Denmark, hygge is applied rather indiscriminately. Last week the New York Times devoted an entire article to achieving hygge while riding the city's subway, of all places. "A train, after all, is basically a large sled that travels underground, in the dark," it said, trying too hard to find a hint of Nordicness on the overcrowded railway.
READ ALSO: Danish word of the day – hyggeracisme
Hygge has become an exotic and mysterious word to describe more or less anything you want. It is as if someone decided that the English word "nice" had a magical meaning that contained the secret to true happiness, and then the whole non-English speaking world made great efforts to achieve the perfect feeling of "nice".
A second problem with hygge is that, in Denmark itself, it seems to operate like a badge of Danishness that can only be enjoyed by Danes themselves – a kind of cultural border that outsiders cannot cross. You can walk down a Danish street in the dark, one journalist was told, look through the windows and spot who is Danish and who is foreign just by whether their lighting is hygge or not.
When writer Helen Russell spent a year in Denmark, she was intrigued by hygge and asked a lifestyle coach about it. "It's hard to explain, it's just something that all Danes know about," she was told. How could an immigrant to Denmark get properly hygge, Russell asked? "You can't. It's impossible," was the unhelpful reply. It can't be a coincidence that the far-right Danish Peoples Party has put a clear emphasis on hygge, as if immigration is a threat to hygge and therefore to Danishness itself.
READ ALSO: It's official – Hygge is now an English word
Outside Denmark, this exclusivity has taken on another aspect: where are all the children? Where amid the hygge hype are the bits of lego on the floor, the mess of discarded clothes, toys and half-eaten food, the bleeping iPads and noisy TVs? "Hygge is about a charmed existence in which children are sinisterly absent," noted the design critic for the Financial Times. It's as if the Pied Piper of hygge has spirited them away so you can get truly cosy.
But there is a bigger problem with hygge. It is largely an invention, the work of some clever marketing executives. After spotting a feature about hygge on the BBC website, two of London's biggest publishers realised this was "a perfect distillation of popular lifestyle obsessions". They set out to find people who could write books for them on the subject, and so two bestsellers were born, spawning a host of imitations.
Sweden has a different word that means roughly the same thing: mys (the noun) and mysig (the adjective). There have even been some half-hearted attempts to sell mys to a foreign audience in the same way as hygge. But the real meaning of mys in Swedish society is rather different, it seems to me. The reason for this, I think, is that mys has become so firmly identified with Friday nights, or fredagsmys – the "Friday cosy".
Fredagsmys is a collective sigh of relief that the working / school week is over, and now it is time for the whole family to come together in front of some trashy TV with a plate of easy finger-food. The word first appeared in the 1990s, entered the dictionary in 2006, and became a semi-official national anthem three years later with this joyous ad for potato crisps:
In this portrayal, mys is radically different to hygge. It is a celebration of the ordinary, witty and multi-cultural, featuring green-haired goths and a mixed-race family with small children. Food is central to fredagsmys, and what is the typical food of choice? Mexican, of course! Not a herring in sight.
Why Mexican? It seems nobody is really sure, but tacofredag now has roots in Swedish society. Tacos, tortillas, and all the accompanying spices and sauces take up a whole aisle of the typical Swedish supermarket. Swedes are accustomed to eating bread with various bits and pieces on top, according to a specialist in Swedish food culture, while the Swedish tradition of smörgåsbord (open sandwiches) makes a buffet meal seem natural. The fussiness of tacos is even reminiscent of a kräftskiva crayfish party.
There is no cultural exclusivity here. On the contrary, fredagsmys food could equally be Italian, North American, Middle-Eastern, British or French. And children are absolutely central to a good Friday cosy.
With Swedish mys, everybody is welcome. Get cosy and relax, but do it by mixing and getting messy, rather than retreating into pure, perfect, rarified isolation. There is a time and a place for hygge. But the Swedish version is more real, more fun, and more inclusive.
David Crouch is the author of Almost Perfekt: How Sweden Works and What Can We Learn From It. He is a freelance journalist and a lecturer in journalism at Gothenburg University
David Crouch [email protected] @davidgcrouch
OPINION: This is Russia's war, but we Europeans need to learn fast from our mistakes
OPINION: Sweden's Covid travel ban is getting more and more absurd


Today my registration request came through the post for The University of Worcester! It is a sure sign that this really is happening! Incase you are wondering why Worcester Uni, well it is linked to Somerset SCITT as the course provider. ID card should be on its way soon….woo hoo!
I've just started a new role at the School of Ed at the University of Leicester as the PGCE Partnership Manager.
I will be helping to develop and manage the relationships that we build with schools who play a huge role in training our PGCE students how to be teachers.
I turned to Twitter to help me learn more about good/new practice in initial teacher training and find out what others think about PGCEs. So I will read your blog with interest – and pitch in where I can!
Hi Korin, thanks for the comment and it is great to hear from you. You are the first one to comment as this blog is just a few weeks old. Good luck with your new role and let me know if I can be of help at all during the next 12 months. Enjoy the blog and Twitter updates!
Cheers – I've got as much to learn as you do!


This shiitake and tofu veggie ramen cup is rich and deep in flavor. This easy ramen noodles recipe is so hearty even your meat loving friends won't miss the meat. We took our Vegetarian Vegetable cup noodles and added baby bok choy, soft boiled egg, shiitake mushrooms and lightly breaded tofu.
Cook the veggie ramen cup according to package instructions.
In a plastic bag, add the tofu and corn starch and shake until the tofu is evenly coated.
Add the sesame oil to a pan and fry the tofu on medium heat for 10 minutes or until tofu is evenly brown.
Assemble the bowl by placing the bok choy into the broth and letting it cook for 30 seconds. Then add the shiitake mushrooms, tofu, green onions, soft boiled egg and sesame seeds. Then slurp up and Savor the Good.


Be quick or miss out on this prime 338m2 survey strata block of land.
Conveniently located between Beaufort Street, Mt Lawley high school and the Mt Lawley golf course, this level block has a 15.29m frontage with new fences and services ready.
Fabulous plans for double homes with approvals already through.
Neat 3 bedroom home on 158sqm block in quiet leafy Seventh Avenue on the Mt Lawley border in sought after Inglewood.
$10,000 First Home Owners Grant PLUS a Stamp Duty Exemption!
In the highly sought after Avenue's and West of Beaufort Street (also in the Mount Lawley High School catchment zone) is this picture perfect tuckpointed home.
This substantial family home on 1012sqm block with pool is an excellent rental property but a current DA for a 4 lot strata brings an extra dimension to the equation.
This super classy, perfectly polished ground floor apartment has space for days and every modern amenity the discerning buyer could possibly want or need.
Inglewood is an inner-northern suburb of Perth with a rich history and heritage. Home to more than 5,500 people across three square kilometres, present-day Inglewood is influenced by the charm of its past. Established in 1831, the bulk of Inglewood's landscape stems from its two distinct growth periods, 1904 to 1920 and 1935 to 1940, with renovation and restoration returning the pre-war vintage homes to their former glory.
The lifestyle in Inglewood is one of charm and convenience. Its beautifully old-fashioned suburban landscape is unique, yet its proximity to major urban inner-city hubs ensures modern conveniences and requirements are met. Inglewood's main commercial area is located on Beaufort Street and features retail facilities, cafes, a library, recreation centre and amenities. There is also an aquatic centre, golf course, facilities for tennis and soccer, a major park and a local primary school within the area.


Förster, Frank, Liang, Chunguang, Shkumatov, Alexander V., Beisser, Daniela, Engelmann, Julia C., Schnölzer, Martina, Frohme, Marcus, Müller, Tobias, Schill, Ralph O. and Dandekar, Thomas (2009) Tardigrade workbench: comparing stress-related proteins, sequence-similar and functional protein clusters as well as RNA elements in tardigrades. BMC genomics 10, p. 469.
Tardigrades represent an animal phylum with extraordinary resistance to environmental stress.
To gain insights into their stress-specific adaptation potential, major clusters of related and similar proteins are identified, as well as specific functional clusters delineated comparing all tardigrades and individual species (Milnesium tardigradum, Hypsibius dujardini, Echiniscus testudo, Tulinus stephaniae, Richtersius coronifer) and functional elements in tardigrade mRNAs are analysed. We find that 39.3% of the total sequences clustered in 58 clusters of more than 20 proteins. Among these are ten tardigrade specific as well as a number of stress-specific protein clusters. Tardigrade-specific functional adaptations include strong protein, DNA- and redox protection, maintenance and protein recycling. Specific regulatory elements regulate tardigrade mRNA stability such as lox P DICE elements whereas 14 other RNA elements of higher eukaryotes are not found. Further features of tardigrade specific adaption are rapidly identified by sequence and/or pattern search on the web-tool tardigrade analyzer http://waterbear.bioapps.biozentrum.uni-wuerzburg.de. The work-bench offers nucleotide pattern analysis for promotor and regulatory element detection (tardigrade specific; nrdb) as well as rapid COG search for function assignments including species-specific repositories of all analysed data.
Different protein clusters and regulatory elements implicated in tardigrade stress adaptations are analysed including unpublished tardigrade sequences.


Dream Photography Workshops will be providing an Astrophotography and Landscape photography workshop during a boutique all inclusive weekend getaway.
Join Dale Sharpe and Hamish Stubbs, for an all inclusive weekend getaway from the 28-30th June 2019. It will include astrophotography, long exposure, landscape and drone photography at an exclusive WA location with a view of the Stirling ranges, with the venue being booked out solely for this workshop.


. . . that anarchy is about to become the new norm in 21st century America - It Should Be Obvious . . .
Things are getting out of hand here, and there is no end in sight.
In a world of black and white perceptions, no compromise is available, but here goes . . .
1. Government alone cannot and will not solve the problems which foster the environment that is killing young black men.
Bottom-line, black men and women need to stop having kids without committing to one another for life, and without having the means to support their entire family without government assistance. And yes, this applies to white families as well, but right now, young white men aren't the ones getting killed. Those mothers and fathers need to keep their kids in schools, and stop believing that those schools alone are going to educate their children.
2. School systems need to improve.
First of all, less bloated administration and more teachers would go a long way. Second, teachers unions should be disbanded; they serve no purpose except to protect teacher jobs, not enhance teacher performance. Curricula need to be devised to teach our kids 21st century skills so that they can function in a 21st century workforce.
And they need to be taught about this country's history and beginnings. They need to be taught that government is a partner, not a provider.
And any school that fails in these tasks needs to be able to be taken over by the state government for fixing. Too many systems with failing schools and dismal records are still operating with the people the voters are too stupid to vote out of office.
3. Stop exaggerating the problem.
Yes, it's tragic when anyone, black or white, is killed by law enforcement - especially if that death could have been avoided through many different means, but this isn't an epidemic. It's just that in the media-driven environment we live in, those deaths are blown out of proportion by a media and a culture looking for an excuse to vent their anger.
There was a woman on last night's 'The Kelly File', a "community activist" from Chicago, whose answer to these killings was to eliminate all police forces and bring in "community-driven solutions" - whatever that means. Of course, she failed to provide any specifics on just what those solutions might be, nor failed to address the black-on-black murder rate in her home town - the murder capital of the world. In some ways, I actually applaud her basic thought, that government solutions aren't working, but I'll bet that she'd be back-pedaling all day long and into the night if she was told that she shouldn't expect government solutions to provide jobs, pay, healthcare or welfare because they aren't working, either.
Yes, it's embarrassing (I guess - I've never been arrested - but then, I've never done anything that might warrant arrest, either), but resisting escalates the situation into confrontation. There are thankfully few situations where police come in as the aggressor and ramp up the testosterone levels of situations. They are almost always in the mode of ramping up the response to someone who is resisting their authority.
5. Police need better training.
In the recent killing in Minnesota, police were attempting to restrain a resisting (see?) man. As they were attempting to restrain him, one officer was using one hand to try to control the perp, while his other hand held his un-holstered gun. THAT is never proper police procedure.
6. Police need to clean up their ranks.
There are bad cops out there. Cops who don't have the mental makeup to think through situations when the environment escalates, and cops who are flat-out bigots or racists. Cops need to stop protecting cops who they know don't meet the standards that the 21st century requires of them. It's like the medical profession protecting bad doctors; sooner or later someone's going to get hurt or die. In addition, these useless tail-light stops need to end. So someone's tail-light is out - big deal. This is just another reason for bad cops to harass usually innocent people, and they lead to far too many unnecessary confrontations. Same with seat belt stops. There is NO Constitutional authority for government to protect us from ourselves, and seat belt laws are nothing but a nanny-state gone amok.
7. Stop blaming (fill-in-the-blank) for your problems.
The only person to blame for your lot in life is yourself - no one else.


text:
Ventura City Council Moves Toward Making Main Street Moves A More Permanent Attraction In Downtown Ventura
Ventura, CA. – The Ventura City Council voted 7-0 at its meeting on November 8 to make Main Street Moves long-term with a full closure of five blocks in Downtown Ventura, retaining the existing curb, gutter, and sidewalk configuration through a flexible design approach.
Discussions included maintaining a pedestrian-friendly area in keeping Main Street closed to traffic from San Buenaventura Mission to Fir Street, with an additional focus on potentially keeping California Street closed to traffic.
"During the pandemic, the City reimagined the use of public spaces and joined with Downtown Ventura Partners to launch Main Street Moves, which helped many local businesses not only survive but thrive," said Mayor Sofia Rubalcava. "Thousands of people have expressed strong support for keeping streets closed and maintaining outdoor dining and shopping areas. It's exciting to hear that kind of positive public response as we look at design, cost, and logistics for supporting a semi-permanent downtown street closure for Main Street Moves."
The design approach includes the installation of bollards at the intersections and furnishings that are removeable, allowing the modification of the closure as needed with the evolution of downtown and the needs of the space. The design would open back up the existing sidewalks, use the existing angled parking spaces for businesses to use for outdoor seating and dining in the form of parklets, and keep the existing travel lanes free and clear to accommodate delivery trucks, service vehicles, and emergency vehicles.
The City Council also voted to have City staff work with consultants to study traffic impacts, environmental impacts, obtain a bid for removable bollards, and design standards for the parklets, all which will guide the process to the full closure. Additionally, an appointed ad hoc committee will be created to focus on improvements and cohesive design to the Mission Park and Figueroa Plaza.
To encourage participation for both restaurants and retailers, staff will create a fee and lease structure for use of the public right of way space to support the activation of the street and have critical mass of participants.
In December 2021, the continuation or issuance of a new interim special use permit for Main Street Moves will be brought to City Council while staff finalizes the full closure program with the necessary studies. Main Street Moves currently operates under a Special Use Permit and Temporary Emergency Ordinance, which are set to expire on January 7, 2022.
Visit www.cityofventura.ca.gov/OutdoorDiningProgram to learn more about Main Street Moves and view reports, and survey results.
Contact: Heather Sumagaysay, Public Information Officer, [email protected]
delivery trucks
Ventura City Council
C. E. Voigtsberger
Ah, yeesss, another hare-brained scheme to "improve" business downtown. I used to cringe whenever the geniuses on the hill dreamed up another scheme to "help" the businesses downtown.
My reply to them was always, "Just leave me alone. I will figure out a way to improve my business."
Every "project" they schemed up wound up costing me more money in lost sales than if I had paid to have the project done in front of my business by private contractor.
For starters, I would not have torn up the sidewalks when the whether forecast for the previous ten days was that we were going to have a gully washer of a storm hit us.
For once the weather folks were right. The contractor had no sooner scoop-loaded the chunks of sidewalk in the truck when it started to rain and continued for the next three days.
During the construction, a retired Navy LtCdr (CEC) pointed out to the city project engineer that water still ran downhill and the way the sidewalk was laid out it was going to run right to the front door of the then American Commercial Bank building. The engineer rather asininely replied that "they knew what they were doing."
Guess the engineer had delusions of grandeur about being ableto channel water uphill. The first decent rain we got the bank had to put out sandbags and continue to do so for every rainfall thereafter. Maybe the engineer knew that SoCal was about to enter into what may turn into a 500 year drought. Several centuries ago there was a 500 year drought in the area according to folks who claim to know such things. If that is true, no reason why we couldn't have another one. So the problem of rain water running into the building no longer the American Commercial Bank will become less and less of a problem as the drought gets more and more severe.
Bill To Block Federal Funds For Schools That 'Indoctrinate With Critical Race Theory'


Pet emergencies, accidents, and illnesses are unfortunately an inevitable aspect of being a pet owner. We understand how upsetting it is when your pet is sick or injured. Deerfield Animal Hospital offers pet emergency services and critical care veterinary medical services.
During business hours we welcome pet emergencies at Deerfield Animal Hospital and encourage you to call us or come right in. However, outside our business hours, we recommend you contact the following emergency pet hospitals in San Antonio.


text:
Dr. Katharine Greenaway
Katharine (Katie) Greenaway is a Senior Lecturer in social psychology at the University of Melbourne (katharinegreenaway.com). Katie completed her PhD at the University of Queensland before being awarded a fellowship with the Canadian Institute for Advanced Research and an ARC Discovery Early Career Research Award. She is currently funded by an ARC Future Fellowship and an ARC Discovery Project. Katie's research aims to understand how people form social connections, and what benefits these connections have for people's well-being and social lives. For this work, Katie has received multiple awards for early career research excellence and has attracted over $3 million in research funding.
Dr. William Bingley
William Bingley is a postdoctoral research fellow in psychology at the University of Queensland, specialising in communication, identity, and emotion. William's research suggests that 'information access regulation' concepts such as secrecy, confidentiality, and privacy affect individual, interpersonal, and group outcomes through a shared mechanism—social identity. In addition to this line of research, William is currently working on projects relating to human-centred AI, eco-anxiety, video-teleconferencing, collective action, and confidentiality breaches.
Ms. Anh Tran
Anh Tran is a PhD candidate in the Melbourne School of Psychological Sciences. Her research focuses on emotions and emotion regulation as an interpersonal process in everyday life. A Master of Applied Psychology graduate from the University of Melbourne, she is also interested in translating research findings into actionable insights to solve practical problems.
Dr. Candice Boyd
Candice Boyd is an artist-geographer with a background in clinical psychology. She completed a second PhD in Cultural Geography and the Creative Arts at the University of Melbourne in 2015 and is now an ARC DECRA Fellow in the School of Geography, Earth and Atmospheric Sciences. She is currently researching spaces of mental health and well-being, regional youth engagement, and climate-related mental health issues. She is also a Research Associate with the Indigenous Knowledge Institute at the University of Melbourne, studying the social and emotional well-being of Aboriginal Elders in regional Australia.
Dr. Nicholas Van Dam
Nicholas Van Dam is the inaugural Director of the Contemplative Studies Centre and a Senior Lecturer in the Melbourne School of Psychological Sciences at the University of Melbourne. Nicholas is a highly regarded global leader in contemplative research and practice. His vision for the Contemplative Studies Centre reflects a desire for inclusivity, authenticity, integrity, and excellence, embedded within a rigorous ethical framework to ensure retention of the ethos of contemplative practices while simultaneously promoting their empirical study.
Dr. Kari Gibson
Kari Gibson is a psychologist at The Viewpoint and a Research Fellow at Phoenix Australia, the Australian National Centre of Excellence in Posttraumatic Mental Health. Her research explores the relationships between climate change, environmental disaster and mental health, and ways to increase resilience and support recovery after disaster among marginalized populations.
Dr. Elise Kalokerinos
Elise Kalokerinos is a Senior Lecturer in the Melbourne School of Psychological Sciences, where she co-directs the Functions of Emotions in Everyday Life (FEEL) Lab. Her research centres on emotion, motivation, and self-regulation. She uses multiple methods to investigate these topics, with a focus on experience sampling studies conducted in everyday life.
Dr. Yoshihisa Kashima
Yoshihisa Kashima is Professor of Psychology at the University of Melbourne. His research focuses on the psychology of cultural dynamics – how psychological processes contribute to the formation, maintenance, and transformation of culture over time, with particular emphasis on culture of sustainability. He is currently interested in computational modelling of cultural dynamics in complex social-ecological systems (interaction of human population with ecosystems), and his long-term aspiration is to understand the complex interplay among psychological processes, social networks dynamics, and cultural transformation in contemporary society.
Dr. Peter Koval
Peter Koval is a Senior Lecturer in Psychology at the University of Melbourne. His research interests lie at the intersection of social, personality and clinical psychology with a focus on everyday emotional processes, including how people experience and regulate their emotions in response to everyday events, and how these processes relate to wellbeing and psychopathology.
Ms. Dianna McDonald
Dianna McDonald is a researcher in the Behavioural Insights and Social Research Team at Sustainability Victoria. She has been at SV for 4 years and during this time has undertaken two major pieces of state-wide social research - these include Victorians' Perceptions of Climate Change and the Linking Health and Climate Change research which included surveying the public as well as over 700 Victorian healthcare professionals. Prior to joining SV she spent several years working in health and research organisations, including 8 years in Oxford at the Picker Institute measuring patient centred care.
On-going areas of interest include increasing the public understanding of the links between health and climate change, and the perceived priority of climate change action.


Special Issue "Solution Models based on Symmetric and Asymmetric Information"
This Special Issue is intended to cover symmetry and asymmetry phenomena occurring in real-life problems. Symmetry and structural regularity are essential concepts in many natural and man-made objects and play a crucial role in problems solutions. While the complexity and risks inherent in problem solution models, along with different indicators of success and failure, may contribute to the difficulties in their performance evaluation, and, generally multiple solutions exist. The existence of information asymmetry also causes difficulties when achieving optimal solution. Therefore, various solution models can be proposed as integrated tool to find a balance between components of sustainable global development, i.e., to find symmetry axe with respect to goals, risks, and constraints to cope with the complicated problems. We invite authors to submit their theoretical or experimental research presenting engineering and other problem solution models dealing with symmetry and asymmetry of different types of information.
This Special Issue covers symmetry and asymmetry phenomena occurring in real-life problems. We invited authors to submit their theoretical or experimental research presenting engineering and economic problem solution models dealing with the symmetry or asymmetry of different types of information. The issue gained [...] Read more.
The article analyzes Bernoulli's binary sequences in the representation of empirical events about water usage and continuous expenditure systems. The main purpose is to identify among variables that constitute water resources consumption at public schools, the link between consumption and expenditures oscillations. It [...] Read more.
The success of any business depends fundamentally on the possibility of balancing (symmetry) needs and their satisfaction, that is, the ability to properly define a set of success indicators. It is necessary to continuously monitor and measure the indicators that have the greatest [...] Read more.
There are numerous models for solving the efficiency evaluation in data envelopment analysis (DEA) with fuzzy input and output data. However, because of the limitation of those strategies, they cannot be implemented for solving fully fuzzy DEA (FFDEA). Furthermore, in real-world problems with [...] Read more.
Quadcopter flight stability is achieved when all of the rotors–propellers generate equal thrust in hover and throttle mode. It requires a control system algorithm for rotor speed adjustment, which is related with the translational vector and rotational angle. Even with an identical propeller [...] Read more.
This paper considers the optimal dividend and capital injection problem for an insurance company, which controls the risk exposure by both the excess-of-loss reinsurance and capital injection based on the symmetry of risk information. Besides the proportional transaction cost, we also incorporate the [...] Read more.
The application of multiple criteria decision-making methods (MCDM) is aimed at choosing the best alternative out of the number of available versions in the absence of the apparently dominant alternative. One of the two major components of multiple criteria decision-making methods is represented [...] Read more.
Pythagorean fuzzy sets are highly appealing in dealing with uncertainty as they allow for greater flexibility in regards to the membership and non-membership degrees by extending the set of possible values. In this paper, we propose a multi-criteria group decision-making approach based on [...] Read more.
In this paper, we extend the Bonferroni mean (BM) operator, generalized Bonferroni mean (GBM) operator, dual generalized Bonferroni mean (DGBM) operator and dual generalized geometric Bonferroni mean (DGGBM) operator with 2-tuple linguistic neutrosophic numbers (2TLNNs) to propose 2-tuple linguistic neutrosophic numbers weighted Bonferroni [...] Read more.
Determination of subjective weights, which are based on the opinions and preferences of decision-makers, is one of the most important matters in the process of multi-criteria decision-making (MCDM). Step-wise Weight Assessment Ratio Analysis (SWARA) is an efficient method for obtaining the subjective weights [...] Read more.