Register a document type interface instance.

@return void
551846
protected function registerDocumentTypeInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Repositories\DocumentType\DocumentTypeInterface', function($app)
		{
			$AuthenticationManager = $app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface');

			return new \Mgallegos\DecimaAccounting\Accounting\Repositories\DocumentType\EloquentDocumentType(new DocumentType(), $AuthenticationManager->getCurrentUserOrganizationConnection());
		});
	}
1159424
private function registerLangPublisher()
    {
        $this->singleton(Contracts\TransPublisher::class, function (Application $app) {
            /**
             * @var  \Illuminate\Filesystem\Filesystem              $files
             * @var  \Arcanedev\LaravelLang\Contracts\TransManager  $manager
             */
            $files   = $app['files'];
            $manager = $app[Contracts\TransManager::class];

            return new TransPublisher($files, $manager, $app->langPath());
        });
    }
78807
public function registerEntity()
    {
        parent::registerEntity();

        // Args
        $args = apply_filters('cuztom_post_type_args', array_merge(
            [
                'label'       => sprintf(__('%s', 'cuztom'), $this->plural),
                'public'      => true,
                'supports'    => ['title', 'editor'],
                'has_archive' => sanitize_title($this->plural),
                'labels'      => [
                    'name'               => sprintf(_x('%s', 'post type general name', 'cuztom'), $this->plural),
                    'singular_name'      => sprintf(_x('%s', 'post type singular title', 'cuztom'), $this->title),
                    'menu_name'          => sprintf(__('%s', 'cuztom'), $this->plural),
                    'all_items'          => sprintf(__('All %s', 'cuztom'), $this->plural),
                    'add_new'            => sprintf(_x('Add New', '%s', 'cuztom'), $this->title),
                    'add_new_item'       => sprintf(__('Add New %s', 'cuztom'), $this->title),
                    'edit_item'          => sprintf(__('Edit %s', 'cuztom'), $this->title),
                    'new_item'           => sprintf(__('New %s', 'cuztom'), $this->title),
                    'view_item'          => sprintf(__('View %s', 'cuztom'), $this->title),
                    'items_archive'      => sprintf(__('%s Archive', 'cuztom'), $this->title),
                    'search_items'       => sprintf(__('Search %s', 'cuztom'), $this->plural),
                    'not_found'          => sprintf(__('No %s found', 'cuztom'), $this->plural),
                    'not_found_in_trash' => sprintf(__('No %s found in trash', 'cuztom'), $this->plural),
                    'parent_item_colon'  => sprintf(__('%s Parent', 'cuztom'), $this->title),
                ],
            ],
            $this->original
        ), $this);

        // Register the post type
        register_post_type($this->name, $args);
    }
1294227
def register_type(cls, name):
    """"""
    x = TypeDefinition(name, (cls,), ())
    Validator.types_mapping[name] = x
1188087
public function registerAutoloader()
    {
        $this->app->afterResolving(DocumentManagerRegistry::class, function (ManagerRegistryInterface $registry) {
            /** @var DocumentManager $manager */
            foreach ($registry->getManagers() as $manager) {
                Autoloader::register(
                    $manager->getConfiguration()->getProxyDir(),
                    $manager->getConfiguration()->getProxyNamespace()
                );

            }
        });
    }
796814
public function registerAssets()
    {
        $id = $this->options['id'];
        $view = $this->getView();
        CoreAsset::register($view);
        $cleanOptions = $this->getClientOptions();
        $js[] = "$('textarea.element-$id').textareaAutoSize();";
        $view->registerJs(implode("\n", $js),View::POS_READY);
    }
487890
public function registerTaxonomy()
    {
        if (function_exists('get_field')) {
            $type_definitions = get_field('avabile_dynamic_taxonomies', 'option');

            if (is_array($type_definitions) && !empty($type_definitions)) {
                foreach ($type_definitions as $type_definition_key => $type_definition) {
                    register_taxonomy(
                        sanitize_title($type_definition['label']),
                        $type_definition['connected_post_types'],
                        array(
                            'label' => $type_definition['label'],
                            'rewrite' => array( 'slug' => $type_definition['slug'] ),
                            'hierarchical' => (bool) $type_definition['hierarchical'],
                            'show_admin_column' => (bool) $type_definition['show_ui'],
                            'show_ui' => (bool) $type_definition['show_ui'],
                            'public' => (bool) $type_definition['public']
                        )
                    );
                }
            }
        }
    }
316499
protected function registerJournalEntryInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Repositories\JournalEntry\JournalEntryInterface', function($app)
		{
			$AuthenticationManager = $app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface');

			return new \Mgallegos\DecimaAccounting\Accounting\Repositories\JournalEntry\EloquentJournalEntry(new JournalEntry(), $app['db'], $AuthenticationManager->getCurrentUserOrganizationConnection());
		});
	}
415583
public function registerTaxonomyToObjects()
    {
        // register Taxonomy to each of the PostTypes assigned
        if (!empty($this->posttypes)) {
            foreach ($this->posttypes as $posttype) {
                register_taxonomy_for_object_type($this->name, $posttype);
            }
        }
    }
228063
protected function registerIntrospectionTypes()
    {
        $this->container
            ->share(GraphQL::SCHEMA_INTROSPECTION, function () {
                return newObjectType([
                    'name'            => GraphQL::SCHEMA_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     =>
                        'A GraphQL Schema defines the capabilities of a GraphQL server. It ' .
                        'exposes all available types and directives on the server, as well as ' .
                        'the entry points for query, mutation, and subscription operations.',
                    'fields'          => function () {
                        return [
                            'types'            => [
                                'description' => 'A list of all types supported by this server.',
                                'type'        => newNonNull(newList(newNonNull(__Type()))),
                                'resolve'     => function (Schema $schema): array {
                                    return \array_values($schema->getTypeMap());
                                },
                            ],
                            'queryType'        => [
                                'description' => 'The type that query operations will be rooted at.',
                                'type'        => newNonNull(__Type()),
                                'resolve'     => function (Schema $schema): ?TypeInterface {
                                    return $schema->getQueryType();
                                },
                            ],
                            'mutationType'     => [
                                'description' =>
                                    'If this server supports mutation, the type that ' .
                                    'mutation operations will be rooted at.',
                                'type'        => __Type(),
                                'resolve'     => function (Schema $schema): ?TypeInterface {
                                    return $schema->getMutationType();
                                },
                            ],
                            'subscriptionType' => [
                                'description' =>
                                    'If this server support subscription, the type that ' .
                                    'subscription operations will be rooted at.',
                                'type'        => __Type(),
                                'resolve'     => function (Schema $schema): ?TypeInterface {
                                    return $schema->getSubscriptionType();
                                },
                            ],
                            'directives'       => [
                                'description' => 'A list of all directives supported by this server.',
                                'type'        => newNonNull(newList(newNonNull(__Directive()))),
                                'resolve'     => function (Schema $schema): array {
                                    return $schema->getDirectives();
                                },
                            ],
                        ];
                    }
                ]);
            });

        $this->container
            ->share(GraphQL::DIRECTIVE_INTROSPECTION, function () {
                return newObjectType([
                    'name'            => GraphQL::DIRECTIVE_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     =>
                        'A Directive provides a way to describe alternate runtime execution and ' .
                        'type validation behavior in a GraphQL document.' .
                        "\n\nIn some cases, you need to provide options to alter GraphQL's " .
                        'execution behavior in ways field arguments will not suffice, such as ' .
                        'conditionally including or skipping a field. Directives provide this by ' .
                        'describing additional information to the executor.',
                    'fields'          => function () {
                        return [
                            'name'        => ['type' => newNonNull(stringType())],
                            'description' => ['type' => stringType()],
                            'locations'   => [
                                'type' => newNonNull(newList(newNonNull(__DirectiveLocation()))),
                            ],
                            'args'        => [
                                'type'    => newNonNull(newList(newNonNull(__InputValue()))),
                                'resolve' => function (Directive $directive): array {
                                    return $directive->getArguments() ?: [];
                                },
                            ],
                        ];
                    }
                ]);
            });

        $this->container
            ->share(GraphQL::DIRECTIVE_LOCATION_INTROSPECTION, function () {
                return newEnumType([
                    'name'            => GraphQL::DIRECTIVE_LOCATION_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     =>
                        'A Directive can be adjacent to many parts of the GraphQL language, a ' .
                        '__DirectiveLocation describes one such possible adjacencies.',
                    'values'          => [
                        DirectiveLocationEnum::QUERY                  => [
                            'description' => 'Location adjacent to a query operation.',
                        ],
                        DirectiveLocationEnum::MUTATION               => [
                            'description' => 'Location adjacent to a mutation operation.',
                        ],
                        DirectiveLocationEnum::SUBSCRIPTION           => [
                            'description' => 'Location adjacent to a subscription operation.',
                        ],
                        DirectiveLocationEnum::FIELD                  => [
                            'description' => 'Location adjacent to a field.',
                        ],
                        DirectiveLocationEnum::FRAGMENT_DEFINITION    => [
                            'description' => 'Location adjacent to a fragment definition.',
                        ],
                        DirectiveLocationEnum::FRAGMENT_SPREAD        => [
                            'description' => 'Location adjacent to a fragment spread.',
                        ],
                        DirectiveLocationEnum::INLINE_FRAGMENT        => [
                            'description' => 'Location adjacent to an inline fragment.',
                        ],
                        DirectiveLocationEnum::SCHEMA                 => [
                            'description' => 'Location adjacent to a schema definition.',
                        ],
                        DirectiveLocationEnum::SCALAR                 => [
                            'description' => 'Location adjacent to a scalar definition.',
                        ],
                        DirectiveLocationEnum::OBJECT                 => [
                            'description' => 'Location adjacent to an object type definition.',
                        ],
                        DirectiveLocationEnum::FIELD_DEFINITION       => [
                            'description' => 'Location adjacent to a field definition.',
                        ],
                        DirectiveLocationEnum::ARGUMENT_DEFINITION    => [
                            'description' => 'Location adjacent to an argument definition.',
                        ],
                        DirectiveLocationEnum::INTERFACE              => [
                            'description' => 'Location adjacent to an interface definition.',
                        ],
                        DirectiveLocationEnum::UNION                  => [
                            'description' => 'Location adjacent to a union definition.',
                        ],
                        DirectiveLocationEnum::ENUM                   => [
                            'description' => 'Location adjacent to an enum definition.',
                        ],
                        DirectiveLocationEnum::ENUM_VALUE             => [
                            'description' => 'Location adjacent to an enum value definition.',
                        ],
                        DirectiveLocationEnum::INPUT_OBJECT           => [
                            'description' => 'Location adjacent to an input object type definition.',
                        ],
                        DirectiveLocationEnum::INPUT_FIELD_DEFINITION => [
                            'description' => 'Location adjacent to an input object field definition.',
                        ],
                    ],
                ]);
            });

        $this->container
            ->share(GraphQL::TYPE_INTROSPECTION, function () {
                return newObjectType([
                    'name'            => GraphQL::TYPE_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     =>
                        'The fundamental unit of any GraphQL Schema is the type. There are ' .
                        'many kinds of types in GraphQL as represented by the `__TypeKind` enum.' .
                        '\n\nDepending on the kind of a type, certain fields describe ' .
                        'information about that type. Scalar types provide no information ' .
                        'beyond a name and description, while Enum types provide their values. ' .
                        'Object and Interface types provide the fields they describe. Abstract ' .
                        'types, Union and Interface, provide the Object types possible ' .
                        'at runtime. List and NonNull types compose other types.',
                    'fields'          => function () {
                        return [
                            'kind'          => [
                                'type'    => newNonNull(__TypeKind()),
                                'resolve' => function (TypeInterface $type) {
                                    if ($type instanceof ScalarType) {
                                        return TypeKindEnum::SCALAR;
                                    }
                                    if ($type instanceof ObjectType) {
                                        return TypeKindEnum::OBJECT;
                                    }
                                    if ($type instanceof InterfaceType) {
                                        return TypeKindEnum::INTERFACE;
                                    }
                                    if ($type instanceof UnionType) {
                                        return TypeKindEnum::UNION;
                                    }
                                    if ($type instanceof EnumType) {
                                        return TypeKindEnum::ENUM;
                                    }
                                    if ($type instanceof InputObjectType) {
                                        return TypeKindEnum::INPUT_OBJECT;
                                    }
                                    if ($type instanceof ListType) {
                                        return TypeKindEnum::LIST;
                                    }
                                    if ($type instanceof NonNullType) {
                                        return TypeKindEnum::NON_NULL;
                                    }

                                    throw new InvalidTypeException(\sprintf('Unknown kind of type: %s', (string)$type));
                                },
                            ],
                            'name'          => ['type' => stringType()],
                            'description'   => ['type' => stringType()],
                            'fields'        => [
                                'type'    => newList(newNonNull(__Field())),
                                'args'    => [
                                    'includeDeprecated' => ['type' => booleanType(), 'defaultValue' => false],
                                ],
                                'resolve' => function (TypeInterface $type, array $args):
                                ?array {
                                    ['includeDeprecated' => $includeDeprecated] = $args;

                                    if ($type instanceof ObjectType || $type instanceof InterfaceType) {
                                        $fields = \array_values($type->getFields());

                                        if (!$includeDeprecated) {
                                            $fields = \array_filter($fields, function (Field $field) {
                                                return !$field->isDeprecated();
                                            });
                                        }

                                        return $fields;
                                    }

                                    return null;
                                },
                            ],
                            'interfaces'    => [
                                'type'    => newList(newNonNull(__Type())),
                                'resolve' => function (TypeInterface $type): ?array {
                                    return $type instanceof ObjectType ? $type->getInterfaces() : null;
                                },
                            ],
                            'possibleTypes' => [
                                'type'    => newList(newNonNull(__Type())),
                                'resolve' => function (
                                    TypeInterface $type,
                                    array $args,
                                    array $context,
                                    ResolveInfo $info
                                ):
                                ?array {
                                    /** @var Schema $schema */
                                    $schema = $info->getSchema();
                                    /** @noinspection PhpParamsInspection */
                                    return $type instanceof AbstractTypeInterface ? $schema->getPossibleTypes($type) : null;
                                },
                            ],
                            'enumValues'    => [
                                'type'    => newList(newNonNull(__EnumValue())),
                                'args'    => [
                                    'includeDeprecated' => ['type' => booleanType(), 'defaultValue' => false],
                                ],
                                'resolve' => function (TypeInterface $type, array $args): ?array {
                                    ['includeDeprecated' => $includeDeprecated] = $args;

                                    if ($type instanceof EnumType) {
                                        $values = \array_values($type->getValues());

                                        if (!$includeDeprecated) {
                                            $values = \array_filter($values, function (Field $field) {
                                                return !$field->isDeprecated();
                                            });
                                        }

                                        return $values;
                                    }

                                    return null;
                                },
                            ],
                            'inputFields'   => [
                                'type'    => newList(newNonNull(__InputValue())),
                                'resolve' => function (TypeInterface $type): ?array {
                                    return $type instanceof InputObjectType ? $type->getFields() : null;
                                },
                            ],
                            'ofType'        => ['type' => __Type()],
                        ];
                    }
                ]);
            });

        $this->container
            ->share(GraphQL::FIELD_INTROSPECTION, function () {
                return newObjectType([
                    'name'            => GraphQL::FIELD_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     =>
                        'Object and Interface types are described by a list of Fields, each of ' .
                        'which has a name, potentially a list of arguments, and a return type.',
                    'fields'          => function () {
                        return [
                            'name'              => ['type' => newNonNull(stringType())],
                            'description'       => ['type' => stringType()],
                            'args'              => [
                                'type'    => newNonNull(newList(newNonNull(__InputValue()))),
                                'resolve' => function (ArgumentsAwareInterface $directive): array {
                                    return $directive->getArguments() ?? [];
                                },
                            ],
                            'type'              => ['type' => newNonNull(__Type())],
                            'isDeprecated'      => ['type' => newNonNull(booleanType())],
                            'deprecationReason' => ['type' => stringType()],
                        ];
                    }
                ]);
            });

        $this->container
            ->share(GraphQL::INPUT_VALUE_INTROSPECTION, function () {
                return newObjectType([
                    'name'            => GraphQL::INPUT_VALUE_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     =>
                        'Arguments provided to Fields or Directives and the input fields of an ' .
                        'InputObject are represented as Input Values which describe their type ' .
                        'and optionally a default value.',
                    'fields'          => function () {
                        return [
                            'name'         => ['type' => newNonNull(stringType())],
                            'description'  => ['type' => stringType()],
                            'type'         => ['type' => newNonNull(__Type())],
                            'defaultValue' => [
                                'type'        => stringType(),
                                'description' =>
                                    'A GraphQL-formatted string representing the default value for this ' .
                                    'input value.',
                                'resolve'     => function (/*$inputValue*/) {
                                    // TODO: Implement this when we have support for printing AST.
                                    return null;
                                }
                            ],
                        ];
                    }
                ]);
            });

        $this->container
            ->share(GraphQL::ENUM_VALUE_INTROSPECTION, function () {
                return newObjectType([
                    'name'            => GraphQL::ENUM_VALUE_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     =>
                        'One possible value for a given Enum. Enum values are unique values, not ' .
                        'a placeholder for a string or numeric value. However an Enum value is ' .
                        'returned in a JSON response as a string.',
                    'fields'          => function () {
                        return [
                            'name'              => ['type' => newNonNull(stringType())],
                            'description'       => ['type' => stringType()],
                            'isDeprecated'      => ['type' => newNonNull(booleanType())],
                            'deprecationReason' => ['type' => stringType()],
                        ];
                    }
                ]);
            });

        $this->container
            ->share(GraphQL::TYPE_KIND_INTROSPECTION, function () {
                return newEnumType([
                    'name'            => GraphQL::TYPE_KIND_INTROSPECTION,
                    'isIntrospection' => true,
                    'description'     => 'An enum describing what kind of type a given `__Type` is.',
                    'values'          => [
                        TypeKindEnum::SCALAR       => [
                            'description' => 'Indicates this type is a scalar.',
                        ],
                        TypeKindEnum::OBJECT       => [
                            'description' => 'Indicates this type is an object. `fields` and `interfaces` are valid fields.',
                        ],
                        TypeKindEnum::INTERFACE    => [
                            'description' => 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.',
                        ],
                        TypeKindEnum::UNION        => [
                            'description' => 'Indicates this type is a union. `possibleTypes` is a valid field.',
                        ],
                        TypeKindEnum::ENUM         => [
                            'description' => 'Indicates this type is an enum. `enumValues` is a valid field.',
                        ],
                        TypeKindEnum::INPUT_OBJECT => [
                            'description' => 'Indicates this type is an input object. `inputFields` is a valid field.',
                        ],
                        TypeKindEnum::LIST         => [
                            'description' => 'Indicates this type is a list. `ofType` is a valid field.',
                        ],
                        TypeKindEnum::NON_NULL     => [
                            'description' => 'Indicates this type is a non-null. `ofType` is a valid field.',
                        ],
                    ],
                ]);
            });
    }
1116461
protected function registerVoucherTypeManagementInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Services\VoucherTypeManagement\VoucherTypeManagementInterface', function($app)
		{
			return new \Mgallegos\DecimaAccounting\Accounting\Services\VoucherTypeManagement\VoucherTypeManager(
				$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
				$app->make('App\Kwaai\Security\Services\JournalManagement\JournalManagementInterface'),
				$app->make('App\Kwaai\Security\Repositories\Journal\JournalInterface'),
				new	\Mgallegos\LaravelJqgrid\Encoders\JqGridJsonEncoder($app->make('excel')),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\VoucherType\EloquentVoucherTypeGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app['translator']
				),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\VoucherType\VoucherTypeInterface'),

				new Carbon(),
				$app['db'],
				$app['translator'],
				$app['config']
			);
		});
	}
1247196
public function registerAssets()
    {
        $id = Inflector::variablize($this->getId());
        $view = $this->getView();
        
        SwitcheryAsset::register($view);
        
        $selector = $id . 'Element';
        $options = [$selector];
        
        if (!empty($this->clientOptions)) {
            $options[] = Json::encode($this->clientOptions);
        }

        $js = new JsExpression(implode(', ', $options));
        $script = <<<EOT
var {$selector} = document.querySelector('{$this->querySelector}');
var {$id} = new Switchery({$js});
EOT;

        if (!empty($this->clientChangeEvent)) {
            $script .= "{$selector}.addEventListener('change', {$this->clientChangeEvent});" . PHP_EOL;
        }

        $view->registerJs($script);
    }
224224
public function registerAssets()
    {
        $view = $this->getView();
        NotifyAsset::register($view);

        $config = [
            'type' => $this->type,
            'closable' => $this->closable,
            'transition' => $this->transition,
            'fadeOut' => $this->fadeOut,
            'message' => $this->message,
            'onClose' => new JsExpression($this->onClose),
            'onClosed' => new JsExpression($this->onClosed)
        ];
        $defaults = Json::encode($config);

        $js = <<<SCRIPT
;(function($, window, document, undefined) {
    $('.alert').toNotify({$defaults}, $('#talmaNotify')).show();
})(window.jQuery, window, document);
SCRIPT;
        $view->registerJs($js);
    }
416934
protected function registerJournalManagementInterface()
	{

		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Services\JournalManagement\JournalManagementInterface', function($app)
		{
			return new JournalManager(
				$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
				$app->make('App\Kwaai\Security\Services\JournalManagement\JournalManagementInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Services\SettingManagement\SettingManagementInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Services\PeriodManagement\PeriodManagementInterface'),
				$app->make('App\Kwaai\Security\Repositories\Journal\JournalInterface'),
				new	\Mgallegos\LaravelJqgrid\Encoders\JqGridJsonEncoder($app->make('excel')),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\EloquentJournalVoucherGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app->make('Mgallegos\DecimaAccounting\Accounting\Services\SettingManagement\SettingManagementInterface'),
					$app->make('excel'),
					$app->make('dompdf.wrapper'),
					new Carbon(),
					$app['translator']
				),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\JournalEntry\EloquentJournalEntryGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface')
				),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\EloquentBalanceSheetGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app['translator']
				),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\EloquentProfitAndLossGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app['translator']
				),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\EloquentTrialBalanceGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app['translator'],
					new Carbon()
				),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\EloquentGeneralLedgerGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app->make('Mgallegos\DecimaAccounting\Accounting\Services\AccountManagement\AccountManagementInterface'),
					$app['translator'],
					new Carbon(),
					$app->make('dompdf.wrapper')
				),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\EloquentTaxControlGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app->make('Mgallegos\DecimaAccounting\Accounting\Services\AccountManagement\AccountManagementInterface'),
					$app['translator'],
					new Carbon()
				),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\JournalVoucher\JournalVoucherInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\JournalEntry\JournalEntryInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\VoucherType\VoucherTypeInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Account\AccountInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\CostCenter\CostCenterInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\FiscalYear\FiscalYearInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Period\PeriodInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\DocumentType\DocumentTypeInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Client\ClientInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Supplier\SupplierInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Employee\EmployeeInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Apportionment\ApportionmentInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\ApportionmentEntry\ApportionmentEntryInterface'),
				new Carbon(),
				$app['db'],
				$app['translator'],
				$app['config']
			);
		});
	}
862980
public function register(Extension $extension)
    {
        if ($extension instanceof DocumentExtension) {
            array_unshift($this->registry[DocumentExtension::class], $extension);
        }
        if ($extension instanceof ElementExtension) {
            array_unshift($this->registry[ElementExtension::class], $extension);
        }
        if ($extension instanceof NamespaceExtension) {
            $this->registry[NamespaceExtension::class][] = $extension;
        }
    }
1201046
public function register()
    {
        $this->app->singleton(Grammar::class);

        $this->app->singleton(Lexer::class);

        $this->app->singleton(Parser::class);

        $this->app->singleton(IntToRomanFilter::class);

        $this->app->singleton(RomanToIntFilter::class);
        $this->app->resolving(RomanToIntFilter::class, function ($element, $app) {
            $element->setLexer($app->make(Lexer::class));
            $element->setParser($app->make(Parser::class));
            return $element;
        });

        $this->app->alias(IntToRomanFilter::class, 'intToRoman');
        $this->app->alias(RomanToIntFilter::class, 'romanToInt');
    }
196377
protected function _registerBuiltInTypes()
    {
        $this->registerJsonType("boolean", new Types\BoolType(), array("bool"));
        $this->registerJsonType("float", new Types\FloatType());
        $this->registerJsonType("integer", new Types\IntType(), array("int"));
        $this->registerJsonType("string", new Types\StringType());
        $this->registerJsonType("datetime", new Types\DateTimeType());
    }